2022-03-14 13:44:15 -04:00
|
|
|
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
|
|
|
|
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 syn::Ident;
|
|
|
|
|
|
|
|
// Identifer to the `deno_core` crate.
|
|
|
|
//
|
|
|
|
// If macro called in deno_core, `crate` is used.
|
|
|
|
// If macro called outside deno_core, `deno_core` OR the renamed
|
|
|
|
// version from Cargo.toml is used.
|
|
|
|
fn core_import() -> TokenStream2 {
|
|
|
|
let found_crate =
|
|
|
|
crate_name("deno_core").expect("deno_core not present in `Cargo.toml`");
|
|
|
|
|
|
|
|
match found_crate {
|
|
|
|
FoundCrate::Itself => {
|
|
|
|
// TODO(@littledivy): This won't work for `deno_core` examples
|
|
|
|
// since `crate` does not refer to `deno_core`.
|
|
|
|
// examples must re-export deno_core to make this work
|
|
|
|
// until Span inspection APIs are stabalized.
|
|
|
|
//
|
|
|
|
// https://github.com/rust-lang/rust/issues/54725
|
|
|
|
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;
|
|
|
|
|
|
|
|
// Preserve the original func as op_foo::call()
|
|
|
|
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)
|
|
|
|
};
|
|
|
|
|
|
|
|
// Generate wrapper
|
|
|
|
quote! {
|
|
|
|
#[allow(non_camel_case_types)]
|
|
|
|
pub struct #name;
|
|
|
|
|
|
|
|
impl #name {
|
|
|
|
pub fn name() -> &'static str {
|
|
|
|
stringify!(#name)
|
|
|
|
}
|
|
|
|
|
2022-03-15 18:43:17 -04:00
|
|
|
pub fn v8_fn_ptr #generics () -> #core::v8::FunctionCallback #where_clause {
|
2022-03-14 13:44:15 -04:00
|
|
|
use #core::v8::MapFnTo;
|
|
|
|
Self::v8_func::<#type_params>.map_fn_to()
|
|
|
|
}
|
|
|
|
|
2022-03-15 18:43:17 -04:00
|
|
|
pub fn decl #generics () -> #core::OpDecl #where_clause {
|
|
|
|
#core::OpDecl {
|
|
|
|
name: Self::name(),
|
|
|
|
v8_fn_ptr: Self::v8_fn_ptr::<#type_params>(),
|
|
|
|
}
|
2022-03-14 13:44:15 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#[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()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate the body of a v8 func for an async op
|
|
|
|
fn codegen_v8_async(core: &TokenStream2, f: &syn::ItemFn) -> TokenStream2 {
|
2022-03-14 18:38:53 -04:00
|
|
|
let (arg_decls, args_tail) = codegen_args(core, f, 1, 2);
|
2022-03-14 13:44:15 -04:00
|
|
|
let type_params = &f.sig.generics.params;
|
|
|
|
|
|
|
|
quote! {
|
|
|
|
use #core::futures::FutureExt;
|
|
|
|
// SAFETY: Called from Deno.core.opAsync. Which retrieves the index using opId table.
|
|
|
|
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);
|
|
|
|
// Fail if promise id invalid (not an int)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-03-14 18:38:53 -04:00
|
|
|
#arg_decls
|
2022-03-14 13:44:15 -04:00
|
|
|
|
|
|
|
// SAFETY: Unchecked cast to external since #core guarantees args.data() is a v8 External.
|
|
|
|
let state_refcell_raw = unsafe {
|
|
|
|
#core::v8::Local::<#core::v8::External>::cast(args.data().unwrap_unchecked())
|
|
|
|
}.value();
|
|
|
|
|
|
|
|
// SAFETY: The Rc<RefCell<OpState>> is functionally pinned and is tied to the isolate's lifetime
|
|
|
|
let state = unsafe {
|
|
|
|
let ptr = state_refcell_raw as *const std::cell::RefCell<#core::OpState>;
|
|
|
|
// Increment so it will later be decremented/dropped by the underlaying func it is moved to
|
|
|
|
std::rc::Rc::increment_strong_count(ptr);
|
|
|
|
std::rc::Rc::from_raw(ptr)
|
|
|
|
};
|
|
|
|
// Track async call & get copy of get_error_class_fn
|
|
|
|
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 {
|
2022-03-14 18:38:53 -04:00
|
|
|
let result = Self::call::<#type_params>(state, #args_tail).await;
|
2022-03-14 13:44:15 -04:00
|
|
|
(promise_id, op_id, #core::_ops::to_op_result(get_class, result))
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generate the body of a v8 func for a sync op
|
|
|
|
fn codegen_v8_sync(core: &TokenStream2, f: &syn::ItemFn) -> TokenStream2 {
|
2022-03-14 18:38:53 -04:00
|
|
|
let (arg_decls, args_tail) = codegen_args(core, f, 1, 1);
|
2022-03-14 13:44:15 -04:00
|
|
|
let ret = codegen_sync_ret(core, &f.sig.output);
|
|
|
|
let type_params = &f.sig.generics.params;
|
|
|
|
|
|
|
|
quote! {
|
|
|
|
// SAFETY: Called from Deno.core.opSync. Which retrieves the index using opId table.
|
|
|
|
let op_id = unsafe {
|
|
|
|
#core::v8::Local::<#core::v8::Integer>::cast(args.get(0)).value()
|
|
|
|
} as usize;
|
|
|
|
|
2022-03-14 18:38:53 -04:00
|
|
|
#arg_decls
|
2022-03-14 13:44:15 -04:00
|
|
|
|
|
|
|
// SAFETY: Unchecked cast to external since #core guarantees args.data() is a v8 External.
|
|
|
|
let state_refcell_raw = unsafe {
|
|
|
|
#core::v8::Local::<#core::v8::External>::cast(args.data().unwrap_unchecked())
|
|
|
|
}.value();
|
|
|
|
|
|
|
|
// SAFETY: The Rc<RefCell<OpState>> is functionally pinned and is tied to the isolate's lifetime
|
|
|
|
let state = unsafe { &*(state_refcell_raw as *const std::cell::RefCell<#core::OpState>) };
|
|
|
|
|
|
|
|
let op_state = &mut state.borrow_mut();
|
2022-03-14 18:38:53 -04:00
|
|
|
let result = Self::call::<#type_params>(op_state, #args_tail);
|
2022-03-14 13:44:15 -04:00
|
|
|
|
|
|
|
op_state.tracker.track_sync(op_id);
|
|
|
|
|
|
|
|
#ret
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-14 18:38:53 -04:00
|
|
|
fn codegen_args(
|
|
|
|
core: &TokenStream2,
|
|
|
|
f: &syn::ItemFn,
|
|
|
|
rust_i0: usize, // Index of first generic arg in rust
|
|
|
|
v8_i0: usize, // Index of first generic arg in v8/js
|
|
|
|
) -> (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)
|
|
|
|
}
|
|
|
|
|
2022-03-14 13:44:15 -04:00
|
|
|
fn codegen_arg(
|
|
|
|
core: &TokenStream2,
|
|
|
|
arg: &syn::FnArg,
|
|
|
|
name: &str,
|
2022-03-14 18:38:53 -04:00
|
|
|
idx: usize,
|
2022-03-14 13:44:15 -04:00
|
|
|
) -> TokenStream2 {
|
|
|
|
let ident = quote::format_ident!("{name}");
|
|
|
|
let pat = match arg {
|
|
|
|
syn::FnArg::Typed(pat) => &pat.pat,
|
|
|
|
_ => unreachable!(),
|
|
|
|
};
|
|
|
|
// Fast path if arg should be skipped
|
|
|
|
if matches!(**pat, syn::Pat::Wild(_)) {
|
|
|
|
return quote! { let #ident = (); };
|
|
|
|
}
|
|
|
|
// Otherwise deserialize it via serde_v8
|
|
|
|
quote! {
|
2022-03-14 18:38:53 -04:00
|
|
|
let #ident = args.get(#idx as i32);
|
2022-03-14 13:44:15 -04:00
|
|
|
let #ident = match #core::serde_v8::from_v8(scope, #ident) {
|
|
|
|
Ok(v) => v,
|
|
|
|
Err(err) => {
|
|
|
|
let msg = format!("Error parsing args: {}", #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 {
|
|
|
|
// Func with no return no-ops
|
|
|
|
syn::ReturnType::Default => return quote! { let ret = (); },
|
|
|
|
// Func with a return Result<T, E>
|
|
|
|
syn::ReturnType::Type(_, ty) => ty,
|
|
|
|
};
|
|
|
|
|
|
|
|
// Optimize Result<(), Err> to skip serde_v8 when Ok(...)
|
|
|
|
let ok_block = if is_unit_result(&**ret_type) {
|
|
|
|
quote! {}
|
|
|
|
} else {
|
|
|
|
quote! {
|
|
|
|
let ret = #core::serde_v8::to_v8(scope, v).unwrap();
|
|
|
|
rv.set(ret);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
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());
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Detects if a type is of the form Result<(), Err>
|
|
|
|
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,
|
|
|
|
}
|
|
|
|
}
|