diff --git a/core/bindings.rs b/core/bindings.rs
index a60db977a0..96225e4cd9 100644
--- a/core/bindings.rs
+++ b/core/bindings.rs
@@ -505,11 +505,11 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
let error = message.get_value().unwrap();
let error_global = v8::Global::new(scope, error);
state
- .pending_promise_exceptions
+ .pending_promise_rejections
.insert(promise_global, error_global);
}
PromiseHandlerAddedAfterReject => {
- state.pending_promise_exceptions.remove(&promise_global);
+ state.pending_promise_rejections.remove(&promise_global);
}
PromiseRejectAfterResolved => {}
PromiseResolveAfterResolved => {
diff --git a/core/ops_builtin_v8.rs b/core/ops_builtin_v8.rs
index c9391a58fb..5128a056b7 100644
--- a/core/ops_builtin_v8.rs
+++ b/core/ops_builtin_v8.rs
@@ -50,9 +50,9 @@ pub(crate) fn init_builtins_v8() -> Vec<OpDecl> {
op_apply_source_map::decl(),
op_set_format_exception_callback::decl(),
op_event_loop_has_more_work::decl(),
- op_store_pending_promise_exception::decl(),
- op_remove_pending_promise_exception::decl(),
- op_has_pending_promise_exception::decl(),
+ op_store_pending_promise_rejection::decl(),
+ op_remove_pending_promise_rejection::decl(),
+ op_has_pending_promise_rejection::decl(),
op_arraybuffer_was_detached::decl(),
]
}
@@ -859,7 +859,7 @@ fn op_event_loop_has_more_work(scope: &mut v8::HandleScope) -> bool {
}
#[op(v8)]
-fn op_store_pending_promise_exception<'a>(
+fn op_store_pending_promise_rejection<'a>(
scope: &mut v8::HandleScope<'a>,
promise: serde_v8::Value<'a>,
reason: serde_v8::Value<'a>,
@@ -871,12 +871,12 @@ fn op_store_pending_promise_exception<'a>(
let promise_global = v8::Global::new(scope, promise_value);
let error_global = v8::Global::new(scope, reason.v8_value);
state
- .pending_promise_exceptions
+ .pending_promise_rejections
.insert(promise_global, error_global);
}
#[op(v8)]
-fn op_remove_pending_promise_exception<'a>(
+fn op_remove_pending_promise_rejection<'a>(
scope: &mut v8::HandleScope<'a>,
promise: serde_v8::Value<'a>,
) {
@@ -885,11 +885,11 @@ fn op_remove_pending_promise_exception<'a>(
let promise_value =
v8::Local::<v8::Promise>::try_from(promise.v8_value).unwrap();
let promise_global = v8::Global::new(scope, promise_value);
- state.pending_promise_exceptions.remove(&promise_global);
+ state.pending_promise_rejections.remove(&promise_global);
}
#[op(v8)]
-fn op_has_pending_promise_exception<'a>(
+fn op_has_pending_promise_rejection<'a>(
scope: &mut v8::HandleScope<'a>,
promise: serde_v8::Value<'a>,
) -> bool {
@@ -899,7 +899,7 @@ fn op_has_pending_promise_exception<'a>(
v8::Local::<v8::Promise>::try_from(promise.v8_value).unwrap();
let promise_global = v8::Global::new(scope, promise_value);
state
- .pending_promise_exceptions
+ .pending_promise_rejections
.contains_key(&promise_global)
}
diff --git a/core/runtime.rs b/core/runtime.rs
index 2f818c7f81..9f1dbf12dc 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -169,7 +169,7 @@ pub struct JsRuntimeState {
pub(crate) js_macrotask_cbs: Vec<v8::Global<v8::Function>>,
pub(crate) js_nexttick_cbs: Vec<v8::Global<v8::Function>>,
pub(crate) has_tick_scheduled: bool,
- pub(crate) pending_promise_exceptions:
+ pub(crate) pending_promise_rejections:
HashMap<v8::Global<v8::Promise>, v8::Global<v8::Value>>,
pub(crate) pending_dyn_mod_evaluate: Vec<DynImportModEvaluate>,
pub(crate) pending_mod_evaluate: Option<ModEvaluate>,
@@ -187,7 +187,7 @@ pub struct JsRuntimeState {
/// It will be retrieved by `exception_to_err_result` and used as an error
/// instead of any other exceptions.
// TODO(nayeemrmn): This is polled in `exception_to_err_result()` which is
- // flimsy. Try to poll it similarly to `pending_promise_exceptions`.
+ // flimsy. Try to poll it similarly to `pending_promise_rejections`.
pub(crate) dispatched_exceptions: VecDeque<v8::Global<v8::Value>>,
pub(crate) inspector: Option<Rc<RefCell<JsRuntimeInspector>>>,
waker: AtomicWaker,
@@ -384,7 +384,7 @@ impl JsRuntime {
unsafe { std::alloc::alloc(layout) as *mut _ };
let state_rc = Rc::new(RefCell::new(JsRuntimeState {
- pending_promise_exceptions: HashMap::new(),
+ pending_promise_rejections: HashMap::new(),
pending_dyn_mod_evaluate: vec![],
pending_mod_evaluate: None,
dyn_module_evaluate_idle_counter: 0,
@@ -1169,7 +1169,7 @@ impl JsRuntime {
// run in macrotasks callbacks so we need to let them run first).
self.drain_nexttick()?;
self.drain_macrotasks()?;
- self.check_promise_exceptions()?;
+ self.check_promise_rejections()?;
// Event loop middlewares
let mut maybe_scheduling = false;
@@ -1688,7 +1688,7 @@ impl JsRuntime {
.handled_promise_rejections
.contains(&promise_global);
if !pending_rejection_was_already_handled {
- state.pending_promise_exceptions.remove(&promise_global);
+ state.pending_promise_rejections.remove(&promise_global);
}
}
let promise_global = v8::Global::new(tc_scope, promise);
@@ -2126,22 +2126,22 @@ impl JsRuntime {
Ok(root_id)
}
- fn check_promise_exceptions(&mut self) -> Result<(), Error> {
+ fn check_promise_rejections(&mut self) -> Result<(), Error> {
let mut state = self.state.borrow_mut();
- if state.pending_promise_exceptions.is_empty() {
+ if state.pending_promise_rejections.is_empty() {
return Ok(());
}
let key = {
state
- .pending_promise_exceptions
+ .pending_promise_rejections
.keys()
.next()
.unwrap()
.clone()
};
- let handle = state.pending_promise_exceptions.remove(&key).unwrap();
+ let handle = state.pending_promise_rejections.remove(&key).unwrap();
drop(state);
let scope = &mut self.handle_scope();
@@ -4046,7 +4046,7 @@ Deno.core.ops.op_async_serialize_object_with_numbers_as_keys({
if (reason.message !== "reject") {
throw Error("unexpected reason: " + reason);
}
- Deno.core.ops.op_store_pending_promise_exception(promise);
+ Deno.core.ops.op_store_pending_promise_rejection(promise);
Deno.core.ops.op_promise_reject();
});
new Promise((_, reject) => reject(Error("reject")));
diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js
index d4a5a0a845..4fd6644dba 100644
--- a/runtime/js/99_main.js
+++ b/runtime/js/99_main.js
@@ -323,13 +323,13 @@ delete Intl.v8BreakIterator;
function promiseRejectCallback(type, promise, reason) {
switch (type) {
case 0: {
- ops.op_store_pending_promise_exception(promise, reason);
+ ops.op_store_pending_promise_rejection(promise, reason);
ArrayPrototypePush(pendingRejections, promise);
WeakMapPrototypeSet(pendingRejectionsReasons, promise, reason);
break;
}
case 1: {
- ops.op_remove_pending_promise_exception(promise);
+ ops.op_remove_pending_promise_rejection(promise);
const index = ArrayPrototypeIndexOf(pendingRejections, promise);
if (index > -1) {
ArrayPrototypeSplice(pendingRejections, index, 1);
@@ -348,7 +348,7 @@ delete Intl.v8BreakIterator;
function promiseRejectMacrotaskCallback() {
while (pendingRejections.length > 0) {
const promise = ArrayPrototypeShift(pendingRejections);
- const hasPendingException = ops.op_has_pending_promise_exception(
+ const hasPendingException = ops.op_has_pending_promise_rejection(
promise,
);
const reason = WeakMapPrototypeGet(pendingRejectionsReasons, promise);
@@ -369,7 +369,7 @@ delete Intl.v8BreakIterator;
const errorEventCb = (event) => {
if (event.error === reason) {
- ops.op_remove_pending_promise_exception(promise);
+ ops.op_remove_pending_promise_rejection(promise);
}
};
// Add a callback for "error" event - it will be dispatched
@@ -382,7 +382,7 @@ delete Intl.v8BreakIterator;
// If event was not prevented (or "unhandledrejection" listeners didn't
// throw) we will let Rust side handle it.
if (rejectionEvent.defaultPrevented) {
- ops.op_remove_pending_promise_exception(promise);
+ ops.op_remove_pending_promise_rejection(promise);
}
}
return true;