Make it possible to throw UncatchableDeveloperError from Rust ops (#42765)

GitOrigin-RevId: 529f78876ca35de864578db072a4f2bba2dffd71

Author: goffrie

crates/isolate/src/ops/errors.rs

@@ -4,26 +4,62 @@ use common::errors::{
     FrameData,
     JsError,
 };
+use deno_core::v8;
 
 use super::OpProvider;
-use crate::environment::UncatchableDeveloperError;
+use crate::{
+    environment::UncatchableDeveloperError,
+    strings,
+};
 
-#[convex_macro::v8_op]
-pub fn op_throw_uncatchable_developer_error<'b, P: OpProvider<'b>>(
+pub(crate) fn throw_uncatchable_developer_error<'b, P: OpProvider<'b>>(
     provider: &mut P,
     message: String,
-    frame_data: Vec<FrameData>,
-) -> anyhow::Result<()> {
-    let js_error = JsError::from_frames(message.clone(), frame_data, None, |s| {
-        provider.lookup_source_map(s)
-    });
+) -> anyhow::Result<!> {
+    let frame_data: anyhow::Result<Vec<FrameData>> = try {
+        let mut scope = v8::HandleScope::new(provider.scope());
+        let empty_string = strings::empty.create(&mut scope)?;
+        let error = v8::Exception::error(&mut scope, empty_string).try_cast::<v8::Object>()?;
+        let stack_string = strings::stack.create(&mut scope)?;
+        // This calls `prepareStackTrace` that populates `__frameData`
+        error
+            .get(&mut scope, stack_string.into())
+            .context("Error.stack threw")?;
+        let frame_data_str = strings::__frameData.create(&mut scope)?;
+        let frame_data_json = error
+            .get(&mut scope, frame_data_str.into())
+            .context("Error.__frameData threw")?
+            .try_cast::<v8::String>()?;
+        let frame_data_json = frame_data_json.to_rust_string_lossy(&mut scope);
+        serde_json::from_str(&frame_data_json)?
+    };
+    let js_error = JsError::from_frames(
+        message.clone(),
+        match frame_data {
+            Ok(data) => data,
+            Err(mut e) => {
+                report_error_sync(&mut e);
+                vec![]
+            },
+        },
+        None,
+        |s| provider.lookup_source_map(s),
+    );
     report_error_sync(&mut anyhow::anyhow!(format!(
         "UncatchableDeveloperError: {}",
         message
     )));
     anyhow::bail!(UncatchableDeveloperError { js_error })
 }
 
+#[convex_macro::v8_op]
+pub fn op_throw_uncatchable_developer_error<'b, P: OpProvider<'b>>(
+    provider: &mut P,
+    message: String,
+) -> anyhow::Result<()> {
+    throw_uncatchable_developer_error(provider, message)?;
+}
+
 /// Do source mapping to find the stack trace for an error.
 /// NOTE if a UDF throws an error, we call this op and then separately do
 /// source mapping again so the yielded error has structured frame data.

crates/isolate/src/strings.rs

@@ -55,6 +55,7 @@ macro_rules! declare_strings {
 // identifier as a string, or explicitly name the string with the `$name =>
 // $string` syntax.
 declare_strings!(
+    __frameData,
     _handler,
     _onInitCallbacks,
     Convex,
@@ -83,5 +84,6 @@ declare_strings!(
     path,
     runRequest,
     setup,
+    stack,
     syscall,
 );

npm-packages/udf-runtime/src/helpers.ts

@@ -44,16 +44,7 @@ export const throwNotImplementedError = (
 };
 
 export const throwUncatchableDeveloperError = (message: string): never => {
-  // Make an error object so we can grab its stack trace and pass it through to
-  // the syscall
-  const error = new Error();
-  // This calls `prepareStackTrace` that populates `__frameData`
-  // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-  error.stack;
-  const frameData = JSON.parse((error as any).__frameData ?? []);
-  performOp("throwUncatchableDeveloperError", message, frameData);
-  // This is not actually reachable because the syscall above will throw
-  return null as never;
+  return performOp("throwUncatchableDeveloperError", message) as never;
 };
 
 export function requiredArguments(length, required, prefix) {