use proc_macro::TokenStream;use proc_macro2::Span;use proc_macro2::TokenStream as TokenStream2;use proc_macro_crate::crate_name;use proc_macro_crate::FoundCrate;use quote::quote;use quote::ToTokens;use syn::Ident;
fn core_import() -> TokenStream2 { let found_crate = crate_name("deno_core").expect("deno_core not present in `Cargo.toml`");
match found_crate { FoundCrate::Itself => { quote!(crate) } FoundCrate::Name(name) => { let ident = Ident::new(&name, Span::call_site()); quote!(#ident) } }}
#[proc_macro_attribute]pub fn op(_attr: TokenStream, item: TokenStream) -> TokenStream { let func = syn::parse::<syn::ItemFn>(item).expect("expected a function"); let name = &func.sig.ident; let generics = &func.sig.generics; let type_params = &func.sig.generics.params; let where_clause = &func.sig.generics.where_clause;
let original_func = { let mut func = func.clone(); func.sig.ident = quote::format_ident!("call"); func };
let core = core_import();
let v8_body = if func.sig.asyncness.is_some() { codegen_v8_async(&core, &func) } else { codegen_v8_sync(&core, &func) };
let docline = format!("Use `{name}::decl()` to get an op-declaration"); quote! { #[allow(non_camel_case_types)] #[doc="Auto-generated by `deno_ops`, i.e: `#[op]`"] #[doc=""] #[doc=#docline] #[doc="you can include in a `deno_core::Extension`."] pub struct #name;
#[doc(hidden)] impl #name { pub fn name() -> &'static str { stringify!(#name) }
pub fn v8_fn_ptr #generics () -> #core::v8::FunctionCallback #where_clause { use #core::v8::MapFnTo; Self::v8_func::<#type_params>.map_fn_to() }
pub fn decl #generics () -> #core::OpDecl #where_clause { #core::OpDecl { name: Self::name(), v8_fn_ptr: Self::v8_fn_ptr::<#type_params>(), } }
#[inline] #original_func
pub fn v8_func #generics ( scope: &mut #core::v8::HandleScope, args: #core::v8::FunctionCallbackArguments, mut rv: #core::v8::ReturnValue, ) #where_clause { #v8_body } } }.into()}
fn codegen_v8_async(core: &TokenStream2, f: &syn::ItemFn) -> TokenStream2 { let arg0 = f.sig.inputs.first(); let uses_opstate = arg0.map(is_rc_refcell_opstate).unwrap_or_default(); let args_head = if uses_opstate { quote! { state, } } else { quote! {} }; let rust_i0 = if uses_opstate { 1 } else { 0 }; let (arg_decls, args_tail) = codegen_args(core, f, rust_i0, 2); let type_params = &f.sig.generics.params;
quote! { use #core::futures::FutureExt; let op_id = unsafe { #core::v8::Local::<#core::v8::Integer>::cast(args.get(0)) }.value() as usize;
let promise_id = args.get(1); let promise_id = #core::v8::Local::<#core::v8::Integer>::try_from(promise_id) .map(|l| l.value() as #core::PromiseId) .map_err(#core::anyhow::Error::from); let promise_id: #core::PromiseId = match promise_id { Ok(promise_id) => promise_id, Err(err) => { #core::_ops::throw_type_error(scope, format!("invalid promise id: {}", err)); return; } };
#arg_decls
let state_refcell_raw = unsafe { #core::v8::Local::<#core::v8::External>::cast(args.data().unwrap_unchecked()) }.value();
let state = unsafe { let ptr = state_refcell_raw as *const std::cell::RefCell<#core::OpState>; std::rc::Rc::increment_strong_count(ptr); std::rc::Rc::from_raw(ptr) }; let get_class = { let state = state.borrow(); state.tracker.track_async(op_id); state.get_error_class_fn };
#core::_ops::queue_async_op(scope, async move { let result = Self::call::<#type_params>(#args_head #args_tail).await; (promise_id, op_id, #core::_ops::to_op_result(get_class, result)) }); }}
fn codegen_v8_sync(core: &TokenStream2, f: &syn::ItemFn) -> TokenStream2 { let arg0 = f.sig.inputs.first(); let uses_opstate = arg0.map(is_mut_ref_opstate).unwrap_or_default(); let args_head = if uses_opstate { quote! { op_state, } } else { quote! {} }; let rust_i0 = if uses_opstate { 1 } else { 0 }; let (arg_decls, args_tail) = codegen_args(core, f, rust_i0, 1); let ret = codegen_sync_ret(core, &f.sig.output); let type_params = &f.sig.generics.params;
quote! { let op_id = unsafe { #core::v8::Local::<#core::v8::Integer>::cast(args.get(0)).value() } as usize;
#arg_decls
let state_refcell_raw = unsafe { #core::v8::Local::<#core::v8::External>::cast(args.data().unwrap_unchecked()) }.value();
let state = unsafe { &*(state_refcell_raw as *const std::cell::RefCell<#core::OpState>) };
let op_state = &mut state.borrow_mut(); let result = Self::call::<#type_params>(#args_head #args_tail);
op_state.tracker.track_sync(op_id);
#ret }}
fn codegen_args( core: &TokenStream2, f: &syn::ItemFn, rust_i0: usize, v8_i0: usize, ) -> (TokenStream2, TokenStream2) { let inputs = &f.sig.inputs.iter().skip(rust_i0).enumerate(); let ident_seq: TokenStream2 = inputs .clone() .map(|(i, _)| format!("arg_{i}")) .collect::<Vec<_>>() .join(", ") .parse() .unwrap(); let decls: TokenStream2 = inputs .clone() .map(|(i, arg)| { codegen_arg(core, arg, format!("arg_{i}").as_ref(), v8_i0 + i) }) .collect(); (decls, ident_seq)}
fn codegen_arg( core: &TokenStream2, arg: &syn::FnArg, name: &str, idx: usize,) -> TokenStream2 { let ident = quote::format_ident!("{name}"); let pat = match arg { syn::FnArg::Typed(pat) => &pat.pat, _ => unreachable!(), }; if matches!(**pat, syn::Pat::Wild(_)) { return quote! { let #ident = (); }; } quote! { let #ident = args.get(#idx as i32); let #ident = match #core::serde_v8::from_v8(scope, #ident) { Ok(v) => v, Err(err) => { let msg = format!("Error parsing args at position {}: {}", #idx, #core::anyhow::Error::from(err)); return #core::_ops::throw_type_error(scope, msg); } }; }}
fn codegen_sync_ret( core: &TokenStream2, output: &syn::ReturnType,) -> TokenStream2 { let ret_type = match output { syn::ReturnType::Default => return quote! { let ret = (); }, syn::ReturnType::Type(_, ty) => ty, };
let ok_block = if is_unit_result(&**ret_type) { quote! {} } else { quote! { match #core::serde_v8::to_v8(scope, v) { Ok(ret) => rv.set(ret), Err(err) => #core::_ops::throw_type_error( scope, format!("Error serializing return: {}", #core::anyhow::Error::from(err)), ), }; } };
quote! { match result { Ok(v) => { #ok_block }, Err(err) => { let err = #core::OpError::new(op_state.get_error_class_fn, err); rv.set(#core::serde_v8::to_v8(scope, err).unwrap()); }, }; }}
fn is_unit_result(ty: &syn::Type) -> bool { let path = match ty { syn::Type::Path(ref path) => path, _ => return false, };
let maybe_result = path.path.segments.first().expect("Invalid return type."); if maybe_result.ident != "Result" { return false; } assert!(!maybe_result.arguments.is_empty());
let args = match &maybe_result.arguments { syn::PathArguments::AngleBracketed(args) => args, _ => unreachable!(), };
match args.args.first().unwrap() { syn::GenericArgument::Type(syn::Type::Tuple(ty)) => ty.elems.is_empty(), _ => false, }}
fn is_mut_ref_opstate(arg: &syn::FnArg) -> bool { tokens(arg).ends_with(": & mut OpState") || tokens(arg).ends_with(": & mut deno_core :: OpState")}
fn is_rc_refcell_opstate(arg: &syn::FnArg) -> bool { tokens(arg).ends_with(": Rc < RefCell < OpState > >") || tokens(arg).ends_with(": Rc < RefCell < deno_core :: OpState > >")}
fn tokens(x: impl ToTokens) -> String { x.to_token_stream().to_string()}