support non-result return values in jsg rust

Author: anonrig

src/rust/jsg-macros/README.md

@@ -20,6 +20,31 @@ pub struct MyRecord {
 }
 ```
 
+## `#[jsg_method]`
+
+Generates FFI callback functions for JSG resource methods. The `name` parameter is optional and defaults to converting the method name from `snake_case` to `camelCase`.
+
+Methods can return `Result<T, E>` (errors become JavaScript exceptions) or return values directly:
+
+```rust
+impl DnsUtil {
+    #[jsg_method(name = "parseCaaRecord")]
+    pub fn parse_caa_record(&self, record: &str) -> Result<CaaRecord, DnsParserError> {
+        // Errors are thrown as JavaScript exceptions
+    }
+
+    #[jsg_method]
+    pub fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    #[jsg_method]
+    pub fn reset(&self) {
+        // Void methods return undefined in JavaScript
+    }
+}
+```
+
 ## `#[jsg_resource]`
 
 Generates boilerplate for JSG resources. Applied to both struct definitions and impl blocks. Automatically implements `jsg::Type::class_name()` using the struct name, or a custom name if provided via the `name` parameter.

src/rust/jsg-macros/lib.rs

@@ -160,6 +160,30 @@ pub fn jsg_struct(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
+/// # Return Types
+///
+/// Methods can return either `Result<T, E>` or directly return `T`:
+///
+/// ```ignore
+/// // Returning Result - errors are thrown as JavaScript exceptions
+/// #[jsg_method]
+/// pub fn parse_record(&self, data: &str) -> Result<Record, Error> {
+///     // implementation
+/// }
+///
+/// // Returning a value directly - no error handling needed
+/// #[jsg_method]
+/// pub fn get_name(&self) -> String {
+///     self.name.clone()
+/// }
+///
+/// // Returning nothing (unit type)
+/// #[jsg_method]
+/// pub fn reset(&self) {
+///     // implementation
+/// }
+/// ```
+///
 /// # Example
 ///
 /// ```ignore
@@ -223,6 +247,9 @@ pub fn jsg_method(_attr: TokenStream, item: TokenStream) -> TokenStream {
         })
         .collect();
 
+    // Determine how to handle the return value based on return type
+    let return_handling = generate_return_handling(&fn_sig.output, fn_name, &arg_refs);
+
     let expanded = quote! {
         #fn_vis #fn_sig {
             #fn_block
@@ -235,14 +262,63 @@ pub fn jsg_method(_attr: TokenStream, item: TokenStream) -> TokenStream {
             #(#unwrap_statements)*
             let this = args.this();
             let self_ = jsg::unwrap_resource::<Self>(&mut lock, this);
-            let result = self_.#fn_name(#(#arg_refs),*);
-            unsafe { jsg::handle_result(&mut lock, &mut args, result) };
+            #return_handling
         }
     };
 
     TokenStream::from(expanded)
 }
 
+/// Checks if a return type is `Result<T, E>`.
+fn is_result_type(ty: &Type) -> bool {
+    let Type::Path(type_path) = ty else {
+        return false;
+    };
+    type_path
+        .path
+        .segments
+        .last()
+        .is_some_and(|seg| seg.ident == "Result")
+}
+
+/// Generates the code for handling the method's return value.
+fn generate_return_handling(
+    output: &syn::ReturnType,
+    fn_name: &syn::Ident,
+    arg_refs: &[quote::__private::TokenStream],
+) -> quote::__private::TokenStream {
+    match output {
+        syn::ReturnType::Default => {
+            // No return value (unit type) - just call the method
+            quote! {
+                self_.#fn_name(#(#arg_refs),*);
+            }
+        }
+        syn::ReturnType::Type(_, ty) => {
+            // Check for explicit unit tuple
+            if matches!(&**ty, Type::Tuple(tuple) if tuple.elems.is_empty()) {
+                return quote! {
+                    self_.#fn_name(#(#arg_refs),*);
+                };
+            }
+
+            if is_result_type(ty) {
+                // Result<T, E> - use handle_result for error handling
+                quote! {
+                    let result = self_.#fn_name(#(#arg_refs),*);
+                    unsafe { jsg::handle_result(&mut lock, &mut args, result) };
+                }
+            } else {
+                // Non-Result type - wrap directly
+                quote! {
+                    let result = self_.#fn_name(#(#arg_refs),*);
+                    unsafe { jsg::handle_value(&mut lock, &mut args, result) };
+                }
+            }
+        }
+    }
+}
+
 fn is_str_reference(ty: &Type) -> bool {
     match ty {
         Type::Reference(type_ref) => {

src/rust/jsg-test/tests/resource_callback.rs

@@ -5,6 +5,9 @@
 //! V8's internal field embedder data type tags are used correctly when getting
 //! aligned pointers from internal fields.
 
+use std::cell::Cell;
+use std::rc::Rc;
+
 use jsg::Lock;
 use jsg::ResourceState;
 use jsg::ResourceTemplate;
@@ -28,6 +31,36 @@ impl EchoResource {
     }
 }
 
+#[jsg_resource]
+struct DirectReturnResource {
+    _state: ResourceState,
+    name: String,
+    counter: Rc<Cell<u32>>,
+}
+
+#[jsg_resource]
+impl DirectReturnResource {
+    #[jsg_method]
+    pub fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    #[jsg_method]
+    pub fn is_valid(&self) -> bool {
+        !self.name.is_empty()
+    }
+
+    #[jsg_method]
+    pub fn get_counter(&self) -> f64 {
+        f64::from(self.counter.get())
+    }
+
+    #[jsg_method]
+    pub fn increment_counter(&self) {
+        self.counter.set(self.counter.get() + 1);
+    }
+}
+
 /// Validates that resource methods can be called from JavaScript.
 /// This test ensures the embedder data type tag is correctly used when
 /// unwrapping resource pointers from V8 internal fields.
@@ -91,3 +124,58 @@ fn resource_method_can_be_called_multiple_times() {
         );
     });
 }
+
+/// Validates that methods can return values directly without Result wrapper.
+#[test]
+fn resource_method_returns_non_result_values() {
+    let harness = crate::Harness::new();
+    harness.run_in_context(|isolate, ctx| unsafe {
+        let mut lock = Lock::from_isolate_ptr(isolate);
+        let counter = Rc::new(Cell::new(42));
+        let resource = jsg::Ref::new(DirectReturnResource {
+            _state: ResourceState::default(),
+            name: "TestResource".to_owned(),
+            counter: counter.clone(),
+        });
+        let mut template = DirectReturnResourceTemplate::new(&mut lock);
+        let wrapped = jsg::wrap_resource(&mut lock, resource, &mut template);
+        ctx.set_global_safe("resource", wrapped.into_ffi());
+
+        assert_eq!(
+            ctx.eval_safe("resource.getName()"),
+            EvalResult {
+                success: true,
+                result_type: "string".to_owned(),
+                result_value: "TestResource".to_owned(),
+            }
+        );
+
+        assert_eq!(
+            ctx.eval_safe("resource.isValid()"),
+            EvalResult {
+                success: true,
+                result_type: "boolean".to_owned(),
+                result_value: "true".to_owned(),
+            }
+        );
+
+        assert_eq!(
+            ctx.eval_safe("resource.getCounter()"),
+            EvalResult {
+                success: true,
+                result_type: "number".to_owned(),
+                result_value: "42".to_owned(),
+            }
+        );
+
+        assert_eq!(
+            ctx.eval_safe("resource.incrementCounter()"),
+            EvalResult {
+                success: true,
+                result_type: "undefined".to_owned(),
+                result_value: "undefined".to_owned(),
+            }
+        );
+        assert_eq!(counter.get(), 43);
+    });
+}

src/rust/jsg/lib.rs

@@ -612,6 +612,18 @@ unsafe fn realm_create(isolate: *mut v8::ffi::Isolate) -> Box<Realm> {
     unsafe { Box::new(Realm::from_isolate(v8::IsolatePtr::from_ffi(isolate))) }
 }
 
+/// Handles a non-Result value by setting the return value directly.
+///
+/// # Safety
+/// The caller must ensure V8 operations are performed within the correct isolate/context.
+pub unsafe fn handle_value<T: Type<This = T>>(
+    lock: &mut Lock,
+    args: &mut v8::FunctionCallbackInfo,
+    value: T,
+) {
+    args.set_return_value(T::wrap(value, lock));
+}
+
 /// Handles a result by setting the return value or throwing an error.
 ///
 /// # Safety
@@ -622,7 +634,7 @@ pub unsafe fn handle_result<T: Type<This = T>, E: std::fmt::Display>(
     result: Result<T, E>,
 ) {
     match result {
-        Ok(result) => args.set_return_value(T::wrap(result, lock)),
+        Ok(value) => unsafe { handle_value(lock, args, value) },
         Err(err) => {
             // TODO(soon): Make sure to use jsg::Error trait here and dynamically call proper method to throw the error.
             let description = err.to_string();