js-disposable-stack.cc

Go to the documentation of this file.

// Copyright 2024 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/objects/js-disposable-stack.h"
 
#include "include/v8-maybe.h"
#include "include/v8-promise.h"
#include "src/base/logging.h"
#include "src/base/macros.h"
#include "src/debug/debug.h"
#include "src/execution/isolate.h"
#include "src/handles/handles.h"
#include "src/handles/maybe-handles.h"
#include "src/heap/factory.h"
#include "src/objects/fixed-array-inl.h"
#include "src/objects/heap-object.h"
#include "src/objects/js-disposable-stack-inl.h"
#include "src/objects/js-function.h"
#include "src/objects/js-objects.h"
#include "src/objects/js-promise-inl.h"
#include "src/objects/js-promise.h"
#include "src/objects/objects-inl.h"
#include "src/objects/objects.h"
#include "src/objects/oddball.h"
#include "src/objects/tagged.h"
 
namespace v8 {
namespace internal {
 
#define CHECK_EXCEPTION_ON_DISPOSAL(isolate, disposable_stack, return_value) \
  do {                                                                       \
    DCHECK(isolate->has_exception());                                        \
    DirectHandle<Object> current_error(isolate->exception(), isolate);       \
    DirectHandle<Object> current_error_message(isolate->pending_message(),   \
                                               isolate);                     \
    if (!isolate->is_catchable_by_javascript(*current_error)) {              \
      return return_value;                                                   \
    }                                                                        \
    isolate->clear_internal_exception();                                     \
    isolate->clear_pending_message();                                        \
    HandleErrorInDisposal(isolate, disposable_stack, current_error,          \
                          current_error_message);                            \
  } while (false)
 
// https://arai-a.github.io/ecma262-compare/?pr=3000&id=sec-disposeresources
MaybeDirectHandle<Object> JSDisposableStackBase::DisposeResources(
    Isolate* isolate, DirectHandle<JSDisposableStackBase> disposable_stack,
    DisposableStackResourcesType resources_type) {
  DCHECK(!IsUndefined(disposable_stack->stack()));
  DCHECK_EQ(disposable_stack->state(), DisposableStackState::kDisposed);
 
  DirectHandle<FixedArray> stack(disposable_stack->stack(), isolate);
 
  // 1. Let needsAwait be false.
  // 2. Let hasAwaited be false.
  // `false` is assigned to both in the initialization of the DisposableStack.
 
  int length = disposable_stack->length();
 
  MaybeDirectHandle<Object> result;
 
  // 3. For each element resource of
  // disposeCapability.[[DisposableResourceStack]], in reverse list order, do
  while (length > 0) {
    //  a. Let value be resource.[[ResourceValue]].
    //  b. Let hint be resource.[[Hint]].
    //  c. Let method be resource.[[DisposeMethod]].
    Tagged<Object> stack_type = stack->get(--length);
 
    Tagged<Object> tagged_method = stack->get(--length);
    DirectHandle<Object> method(tagged_method, isolate);
 
    Tagged<Object> tagged_value = stack->get(--length);
    DirectHandle<Object> value(tagged_value, isolate);
 
    DirectHandle<Object> args[] = {value};
 
    auto stack_type_case = static_cast<int>(Cast<Smi>(stack_type).value());
    DisposeMethodCallType call_type =
        DisposeCallTypeBit::decode(stack_type_case);
    DisposeMethodHint hint = DisposeHintBit::decode(stack_type_case);
 
    //  d. If hint is sync-dispose and needsAwait is true and hasAwaited is
    //  false, then
    //    i. Perform ! Await(undefined).
    //    ii. Set needsAwait to false.
 
    if (hint == DisposeMethodHint::kSyncDispose &&
        disposable_stack->needs_await() == true &&
        disposable_stack->has_awaited() == false) {
      //  i. Perform ! Await(undefined).
      //  ii. Set needsAwait to false.
      disposable_stack->set_needs_await(false);
 
      return ResolveAPromiseWithValueAndReturnIt(
          isolate, isolate->factory()->undefined_value());
    }
 
    //  e. If method is not undefined, then
    if (!IsUndefined(*method)) {
      //    i. Let result be Completion(Call(method, value)).
 
      if (call_type == DisposeMethodCallType::kValueIsReceiver) {
        result = Execution::Call(isolate, method, value, {});
      } else if (call_type == DisposeMethodCallType::kValueIsArgument) {
        result = Execution::Call(isolate, method,
                                 isolate->factory()->undefined_value(),
                                 base::VectorOf(args));
      }
 
      DirectHandle<Object> result_handle;
      //    ii. If result is a normal completion and hint is async-dispose, then
      //      1. Set result to Completion(Await(result.[[Value]])).
      //      2. Set hasAwaited to true.
      if (result.ToHandle(&result_handle)) {
        if (hint == DisposeMethodHint::kAsyncDispose) {
          DCHECK_NE(resources_type, DisposableStackResourcesType::kAllSync);
          disposable_stack->set_length(length);
 
          disposable_stack->set_has_awaited(true);
 
          MaybeDirectHandle<JSReceiver> resolved_promise =
              ResolveAPromiseWithValueAndReturnIt(isolate, result_handle);
 
          if (resolved_promise.is_null()) {
            //    iii. If result is a throw completion, then
            //      1. If completion is a throw completion, then
            //        a. Set result to result.[[Value]].
            //        b. Let suppressed be completion.[[Value]].
            //        c. Let error be a newly created SuppressedError object.
            //        d. Perform CreateNonEnumerableDataPropertyOrThrow(error,
            //        "error", result).
            //        e. Perform CreateNonEnumerableDataPropertyOrThrow(error,
            //         "suppressed", suppressed).
            //        f. Set completion to ThrowCompletion(error).
            //      2. Else,
            //        a. Set completion to result.
            CHECK_EXCEPTION_ON_DISPOSAL(isolate, disposable_stack, {});
          } else {
            return resolved_promise;
          }
        }
      } else {
        CHECK_EXCEPTION_ON_DISPOSAL(isolate, disposable_stack, {});
      }
    } else {
      //  Else,
      //    i. Assert: hint is async-dispose.
      DCHECK_EQ(hint, DisposeMethodHint::kAsyncDispose);
      //    ii. Set needsAwait to true.
      //    iii. NOTE: This can only indicate a case where either null or
      //    undefined was the initialized value of an await using declaration.
      disposable_stack->set_length(length);
      disposable_stack->set_needs_await(true);
    }
  }
 
  // 4. If needsAwait is true and hasAwaited is false, then
  //   a. Perform ! Await(undefined).
  if (disposable_stack->needs_await() == true &&
      disposable_stack->has_awaited() == false) {
    disposable_stack->set_length(length);
    disposable_stack->set_has_awaited(true);
 
    return ResolveAPromiseWithValueAndReturnIt(
        isolate, isolate->factory()->undefined_value());
  }
 
  // 5. NOTE: After disposeCapability has been disposed, it will never be used
  // again. The contents of disposeCapability.[[DisposableResourceStack]] can be
  // discarded in implementations, such as by garbage collection, at this point.
  // 6. Set disposeCapability.[[DisposableResourceStack]] to a new empty List.
  disposable_stack->set_stack(ReadOnlyRoots(isolate).empty_fixed_array());
  disposable_stack->set_length(0);
 
  Handle<Object> existing_error_handle(disposable_stack->error(), isolate);
  DirectHandle<Object> existing_error_message_handle(
      disposable_stack->error_message(), isolate);
  disposable_stack->set_error(*(isolate->factory()->uninitialized_value()));
  disposable_stack->set_error_message(
      *(isolate->factory()->uninitialized_value()));
 
  // 7. Return ? completion.
  if (!IsUninitialized(*existing_error_handle)) {
    if (disposable_stack->suppressed_error_created() == true) {
      // Created SuppressedError is intentionally suppressed here for debug.
      SuppressDebug while_processing(isolate->debug());
      isolate->Throw(*existing_error_handle);
    } else {
      isolate->ReThrow(*existing_error_handle, *existing_error_message_handle);
    }
    return MaybeDirectHandle<Object>();
  }
  return isolate->factory()->true_value();
}
 
MaybeDirectHandle<JSReceiver>
JSDisposableStackBase::ResolveAPromiseWithValueAndReturnIt(
    Isolate* isolate, DirectHandle<Object> value) {
  DirectHandle<JSFunction> promise_function = isolate->promise_function();
  DirectHandle<Object> args[] = {value};
  DirectHandle<Object> result;
  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
      isolate, result,
      Execution::CallBuiltin(isolate, isolate->promise_resolve(),
                             promise_function, base::VectorOf(args)),
      MaybeDirectHandle<JSReceiver>());
  return Cast<JSReceiver>(result);
}
 
Maybe<bool> JSAsyncDisposableStack::NextDisposeAsyncIteration(
    Isolate* isolate,
    DirectHandle<JSDisposableStackBase> async_disposable_stack,
    DirectHandle<JSPromise> outer_promise) {
  MaybeDirectHandle<Object> result;
 
  bool done;
  do {
    done = true;
 
    // 6. Let result be
    //   DisposeResources(asyncDisposableStack.[[DisposeCapability]],
    //   NormalCompletion(undefined)).
    result = DisposeResources(isolate, async_disposable_stack,
                              DisposableStackResourcesType::kAtLeastOneAsync);
 
    DirectHandle<Object> result_handle;
 
    if (result.ToHandle(&result_handle)) {
      if (!IsTrue(*result_handle)) {
        DirectHandle<Context> async_disposable_stack_context =
            isolate->factory()->NewBuiltinContext(
                isolate->native_context(),
                static_cast<int>(
                    JSDisposableStackBase::AsyncDisposableStackContextSlots::
                        kLength));
        async_disposable_stack_context->set(
            static_cast<int>(JSDisposableStackBase::
                                 AsyncDisposableStackContextSlots::kStack),
            *async_disposable_stack);
        async_disposable_stack_context->set(
            static_cast<int>(
                JSDisposableStackBase::AsyncDisposableStackContextSlots::
                    kOuterPromise),
            *outer_promise);
 
        DirectHandle<JSFunction> on_fulfilled =
            Factory::JSFunctionBuilder{
                isolate,
                isolate->factory()
                    ->async_disposable_stack_on_fulfilled_shared_fun(),
                async_disposable_stack_context}
                .Build();
 
        DirectHandle<JSFunction> on_rejected =
            Factory::JSFunctionBuilder{
                isolate,
                isolate->factory()
                    ->async_disposable_stack_on_rejected_shared_fun(),
                async_disposable_stack_context}
                .Build();
 
        DirectHandle<Object> args[] = {on_fulfilled, on_rejected};
        if (Execution::CallBuiltin(isolate, isolate->perform_promise_then(),
                                   Cast<JSPromise>(result_handle),
                                   base::VectorOf(args))
                .is_null()) {
          CHECK_EXCEPTION_ON_DISPOSAL(isolate, async_disposable_stack,
                                      Nothing<bool>());
          done = false;
        }
      } else {
        // 8. Perform ! Call(promiseCapability.[[Resolve]], undefined, « result
        // »).
        if (JSPromise::Resolve(outer_promise,
                               isolate->factory()->undefined_value())
                .is_null()) {
          CHECK_EXCEPTION_ON_DISPOSAL(isolate, async_disposable_stack,
                                      Nothing<bool>());
          done = false;
        }
      }
    } else {
      // 7. IfAbruptRejectPromise(result, promiseCapability).
      DirectHandle<Object> exception(isolate->exception(), isolate);
      if (!isolate->is_catchable_by_javascript(*exception)) {
        return Nothing<bool>();
      }
      isolate->clear_internal_exception();
      isolate->clear_pending_message();
      JSPromise::Reject(outer_promise, exception);
    }
  } while (!done);
 
  return Just(true);
}
 
}  // namespace internal
}  // namespace v8