language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-08-04 19:08:15 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

perf: const op declaration (#18288)

Browse source 
Co-authored-by: Levente Kurusa <lkurusa@kernelstuff.org>
Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>
This commit is contained in:
Divy Srivastava 2023-03-31 18:12:14 +05:30 • committed by GitHub
parent 0f41aff1d9
commit b9a3790932
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
41 changed files with 763 additions and 921 deletions
Download patch file Download diff file Expand all files Collapse all files

125
ops/fast_call.rs
View file

@ -14,12 +14,6 @@ use syn::GenericParam;
use syn::Generics;
use syn::Ident;
use syn::ItemFn;
use syn::ItemImpl;
use syn::Path;
use syn::PathArguments;
use syn::PathSegment;
use syn::Type;
use syn::TypePath;
use crate::optimizer::FastValue;
use crate::optimizer::Optimizer;
@ -62,13 +56,11 @@ pub(crate) fn generate(
}
};
// We've got 3 idents.
// We've got 2 idents.
//
// - op_foo, the public op declaration contains the user function.
// - op_foo_fast, the fast call type.
// - op_foo_fast_fn, the fast call function.
let ident = item_fn.sig.ident.clone();
let fast_ident = Ident::new(&format!("{ident}_fast"), Span::call_site());
let fast_fn_ident =
Ident::new(&format!("{ident}_fast_fn"), Span::call_site());
@ -78,11 +70,6 @@ pub(crate) fn generate(
// struct op_foo_fast <T, U> { ... }
let struct_generics = exclude_lifetime_params(&generics.params);
// std::marker::PhantomData <A>
let phantom_generics: Quote = match struct_generics {
Some(ref params) => q!(Vars { params }, { params }),
None => q!({ <()> }),
};
// op_foo_fast_fn :: <T>
let caller_generics: Quote = match struct_generics {
Some(ref params) => q!(Vars { params }, { ::params }),
@ -90,28 +77,19 @@ pub(crate) fn generate(
};
// This goes in the FastFunction impl block.
let mut segments = Punctuated::new();
{
let mut arguments = PathArguments::None;
if let Some(ref struct_generics) = struct_generics {
arguments = PathArguments::AngleBracketed(parse_quote! {
#struct_generics
});
}
segments.push_value(PathSegment {
ident: fast_ident.clone(),
arguments,
});
}
// struct T <A> {
// _phantom: ::std::marker::PhantomData<A>,
// let mut segments = Punctuated::new();
// {
// let mut arguments = PathArguments::None;
// if let Some(ref struct_generics) = struct_generics {
// arguments = PathArguments::AngleBracketed(parse_quote! {
// #struct_generics
// });
// }
// segments.push_value(PathSegment {
// ident: fast_ident.clone(),
// arguments,
// });
// }
let fast_ty: Quote = q!(Vars { Type: &fast_ident, generics: &struct_generics, phantom_generics }, {
struct Type generics {
_phantom: ::std::marker::PhantomData phantom_generics,
}
});
// Original inputs.
let mut inputs = item_fn.sig.inputs.clone();
@ -345,73 +323,22 @@ pub(crate) fn generate(
let mut generics: Generics = parse_quote! { #impl_generics };
generics.where_clause = where_clause.cloned();
// impl <A> fast_api::FastFunction for T <A> where A: B {
// fn function(&self) -> *const ::std::ffi::c_void {
// f as *const ::std::ffi::c_void
// }
// fn args(&self) -> &'static [fast_api::Type] {
// &[ CType::T, CType::U ]
// }
// fn return_type(&self) -> fast_api::CType {
// CType::T
// }
// }
let item: ItemImpl = ItemImpl {
attrs: vec![],
defaultness: None,
unsafety: None,
impl_token: Default::default(),
generics,
trait_: Some((
None,
parse_quote!(#core::v8::fast_api::FastFunction),
Default::default(),
)),
self_ty: Box::new(Type::Path(TypePath {
qself: None,
path: Path {
leading_colon: None,
segments,
},
})),
brace_token: Default::default(),
items: vec![
parse_quote! {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
#fast_fn_ident #caller_generics as *const ::std::ffi::c_void
}
},
parse_quote! {
#[inline(always)]
fn args(&self) -> &'static [#core::v8::fast_api::Type] {
use #core::v8::fast_api::Type::*;
use #core::v8::fast_api::CType;
&[ #input_variants ]
}
},
parse_quote! {
#[inline(always)]
fn return_type(&self) -> #core::v8::fast_api::CType {
#core::v8::fast_api::CType::#output_variant
}
},
],
};
let mut tts = q!({});
tts.push_tokens(&fast_ty);
tts.push_tokens(&item);
tts.push_tokens(&fast_fn);
let impl_and_fn = tts.dump();
// fast_api::FastFunction::new(&[ CType::T, CType::U ], CType::T, f::<P> as *const ::std::ffi::c_void)
let decl = q!(
Vars { fast_ident, caller_generics },
{
Some(Box::new(fast_ident caller_generics { _phantom: ::std::marker::PhantomData }))
}
Vars { core: core, fast_fn_ident: fast_fn_ident, generics: caller_generics, inputs: input_variants, output: output_variant },
{{
use core::v8::fast_api::Type::*;
use core::v8::fast_api::CType;
Some(core::v8::fast_api::FastFunction::new(
&[ inputs ],
CType :: output,
fast_fn_ident generics as *const ::std::ffi::c_void
))
}}
).dump();
let impl_and_fn = fast_fn.dump();
FastImplItems {
impl_and_fn,
decl,

16
ops/lib.rs
View file

@ -184,19 +184,23 @@ impl Op {
#[doc(hidden)]
impl #name {
pub fn name() -> &'static str {
pub const 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()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr #generics (info: *const #core::v8::FunctionCallbackInfo) #where_clause {
let info = unsafe { &*info };
let scope = &mut unsafe { #core::v8::CallbackScope::new(info) };
let args = #core::v8::FunctionCallbackArguments::from_function_callback_info(info);
let rv = #core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func::<#type_params>(scope, args, rv);
}
pub fn decl #generics () -> #core::OpDecl #where_clause {
pub const fn decl #generics () -> #core::OpDecl #where_clause {
#core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr::<#type_params>(),
v8_fn_ptr: Self::v8_fn_ptr::<#type_params> as _,
enabled: true,
fast_fn: #decl,
is_async: #is_async,

55
ops/optimizer_tests/async_nop.out
View file

@ -6,23 +6,37 @@
pub struct op_void_async;
#[doc(hidden)]
impl op_void_async {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_void_async)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_void_async_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Int32, CallbackOptions],
CType::Void,
op_void_async_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: true,
is_unstable: false,
is_v8: false,
@ -82,25 +96,6 @@ impl op_void_async {
);
}
}
struct op_void_async_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_void_async_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_void_async_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Int32, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_void_async_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/async_result.out
View file

@ -6,23 +6,37 @@
pub struct op_async_result;
#[doc(hidden)]
impl op_async_result {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_async_result)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_async_result_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Int32, Uint32, CallbackOptions],
CType::Void,
op_async_result_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: true,
is_unstable: false,
is_v8: false,
@ -92,25 +106,6 @@ impl op_async_result {
);
}
}
struct op_async_result_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_async_result_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_async_result_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Int32, Uint32, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_async_result_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/callback_options.out
View file

@ -6,23 +6,37 @@
pub struct op_fallback;
#[doc(hidden)]
impl op_fallback {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_fallback)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_fallback_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, CallbackOptions],
CType::Void,
op_fallback_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -51,25 +65,6 @@ impl op_fallback {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_fallback_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_fallback_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_fallback_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_fallback_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/cow_str.out
View file

@ -6,23 +6,37 @@
pub struct op_cow_str;
#[doc(hidden)]
impl op_cow_str {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_cow_str)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_cow_str_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, SeqOneByteString],
CType::Void,
op_cow_str_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -59,25 +73,6 @@ impl op_cow_str {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_cow_str_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_cow_str_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_cow_str_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, SeqOneByteString]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_cow_str_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/f64_slice.out
View file

@ -6,23 +6,37 @@
pub struct op_f64_buf;
#[doc(hidden)]
impl op_f64_buf {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_f64_buf)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_f64_buf_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, TypedArray(CType::Float64), CallbackOptions],
CType::Void,
op_f64_buf_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -77,25 +91,6 @@ impl op_f64_buf {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_f64_buf_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_f64_buf_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_f64_buf_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, TypedArray(CType::Float64), CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_f64_buf_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

20
ops/optimizer_tests/incompatible_1.out
View file

@ -6,17 +6,25 @@
pub struct op_sync_serialize_object_with_numbers_as_keys;
#[doc(hidden)]
impl op_sync_serialize_object_with_numbers_as_keys {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_sync_serialize_object_with_numbers_as_keys)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

20
ops/optimizer_tests/issue16934.out
View file

@ -6,17 +6,25 @@
pub struct send_stdin;
#[doc(hidden)]
impl send_stdin {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(send_stdin)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: true,

20
ops/optimizer_tests/issue16934_fast.out
View file

@ -6,17 +6,25 @@
pub struct send_stdin;
#[doc(hidden)]
impl send_stdin {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(send_stdin)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: true,

20
ops/optimizer_tests/op_blob_revoke_object_url.out
View file

@ -6,17 +6,25 @@
pub struct op_blob_revoke_object_url;
#[doc(hidden)]
impl op_blob_revoke_object_url {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_blob_revoke_object_url)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

55
ops/optimizer_tests/op_ffi_ptr_value.out
View file

@ -6,23 +6,37 @@
pub struct op_ffi_ptr_value;
#[doc(hidden)]
impl op_ffi_ptr_value {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_ffi_ptr_value)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_ffi_ptr_value_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Pointer, TypedArray(CType::Uint32), CallbackOptions],
CType::Void,
op_ffi_ptr_value_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -91,25 +105,6 @@ impl op_ffi_ptr_value {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_ffi_ptr_value_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_ffi_ptr_value_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_ffi_ptr_value_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Pointer, TypedArray(CType::Uint32), CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_ffi_ptr_value_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

20
ops/optimizer_tests/op_print.out
View file

@ -6,17 +6,25 @@
pub struct op_print;
#[doc(hidden)]
impl op_print {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_print)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

55
ops/optimizer_tests/op_state.out
View file

@ -6,23 +6,37 @@
pub struct op_set_exit_code;
#[doc(hidden)]
impl op_set_exit_code {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_set_exit_code)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_set_exit_code_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Int32, CallbackOptions],
CType::Void,
op_set_exit_code_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -59,25 +73,6 @@ impl op_set_exit_code {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_set_exit_code_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_set_exit_code_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_set_exit_code_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Int32, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_set_exit_code_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/op_state_basic1.out
View file

@ -6,23 +6,37 @@
pub struct foo;
#[doc(hidden)]
impl foo {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(foo)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(foo_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Uint32, Uint32, CallbackOptions],
CType::Uint32,
foo_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -86,25 +100,6 @@ impl foo {
};
}
}
struct foo_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for foo_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
foo_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Uint32, Uint32, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Uint32
}
}
#[allow(clippy::too_many_arguments)]
fn foo_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

58
ops/optimizer_tests/op_state_generics.out
View file

@ -6,29 +6,43 @@
pub struct op_foo;
#[doc(hidden)]
impl op_foo {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_foo)
}
pub fn v8_fn_ptr<'scope, SP>() -> deno_core::v8::FunctionCallback
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope, SP>(
info: *const deno_core::v8::FunctionCallbackInfo,
)
where
SP: SomePermission + 'static,
{
use deno_core::v8::MapFnTo;
Self::v8_func::<SP>.map_fn_to()
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func::<SP>(scope, args, rv);
}
pub fn decl<'scope, SP>() -> deno_core::OpDecl
pub const fn decl<'scope, SP>() -> deno_core::OpDecl
where
SP: SomePermission + 'static,
{
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr::<SP>(),
v8_fn_ptr: Self::v8_fn_ptr::<SP> as _,
enabled: true,
fast_fn: Some(
Box::new(op_foo_fast::<SP> {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, CallbackOptions],
CType::Void,
op_foo_fast_fn::<SP> as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -58,28 +72,6 @@ impl op_foo {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_foo_fast<SP> {
_phantom: ::std::marker::PhantomData<SP>,
}
impl<'scope, SP> deno_core::v8::fast_api::FastFunction for op_foo_fast<SP>
where
SP: SomePermission + 'static,
{
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_foo_fast_fn::<SP> as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_foo_fast_fn<'scope, SP>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/op_state_result.out
View file

@ -6,23 +6,37 @@
pub struct foo;
#[doc(hidden)]
impl foo {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(foo)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(foo_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Uint32, Uint32, CallbackOptions],
CType::Uint32,
foo_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -99,25 +113,6 @@ impl foo {
};
}
}
struct foo_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for foo_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
foo_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Uint32, Uint32, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Uint32
}
}
#[allow(clippy::too_many_arguments)]
fn foo_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/op_state_warning.out
View file

@ -6,23 +6,37 @@
pub struct op_listen;
#[doc(hidden)]
impl op_listen {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_listen)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_listen_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, CallbackOptions],
CType::Uint32,
op_listen_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -90,25 +104,6 @@ impl op_listen {
};
}
}
struct op_listen_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_listen_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_listen_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Uint32
}
}
#[allow(clippy::too_many_arguments)]
fn op_listen_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

58
ops/optimizer_tests/op_state_with_transforms.out
View file

@ -6,29 +6,43 @@
pub struct op_now;
#[doc(hidden)]
impl op_now {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_now)
}
pub fn v8_fn_ptr<'scope, TP>() -> deno_core::v8::FunctionCallback
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope, TP>(
info: *const deno_core::v8::FunctionCallbackInfo,
)
where
TP: TimersPermission + 'static,
{
use deno_core::v8::MapFnTo;
Self::v8_func::<TP>.map_fn_to()
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func::<TP>(scope, args, rv);
}
pub fn decl<'scope, TP>() -> deno_core::OpDecl
pub const fn decl<'scope, TP>() -> deno_core::OpDecl
where
TP: TimersPermission + 'static,
{
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr::<TP>(),
v8_fn_ptr: Self::v8_fn_ptr::<TP> as _,
enabled: true,
fast_fn: Some(
Box::new(op_now_fast::<TP> {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, TypedArray(CType::Uint8), CallbackOptions],
CType::Void,
op_now_fast_fn::<TP> as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -105,28 +119,6 @@ impl op_now {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_now_fast<TP> {
_phantom: ::std::marker::PhantomData<TP>,
}
impl<'scope, TP> deno_core::v8::fast_api::FastFunction for op_now_fast<TP>
where
TP: TimersPermission + 'static,
{
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_now_fast_fn::<TP> as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, TypedArray(CType::Uint8), CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_now_fast_fn<'scope, TP>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/opstate_with_arity.out
View file

@ -6,23 +6,37 @@
pub struct op_add_4;
#[doc(hidden)]
impl op_add_4 {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_add_4)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_add_4_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Uint32, Uint32, Uint32, Uint32, CallbackOptions],
CType::Uint32,
op_add_4_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -117,25 +131,6 @@ impl op_add_4 {
};
}
}
struct op_add_4_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_add_4_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_add_4_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Uint32, Uint32, Uint32, Uint32, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Uint32
}
}
#[allow(clippy::too_many_arguments)]
fn op_add_4_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

20
ops/optimizer_tests/option_arg.out
View file

@ -6,17 +6,25 @@
pub struct op_try_close;
#[doc(hidden)]
impl op_try_close {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_try_close)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

55
ops/optimizer_tests/owned_string.out
View file

@ -6,23 +6,37 @@
pub struct op_string_length;
#[doc(hidden)]
impl op_string_length {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_string_length)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_string_length_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, SeqOneByteString],
CType::Uint32,
op_string_length_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -71,25 +85,6 @@ impl op_string_length {
};
}
}
struct op_string_length_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_string_length_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_string_length_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, SeqOneByteString]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Uint32
}
}
#[allow(clippy::too_many_arguments)]
fn op_string_length_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

20
ops/optimizer_tests/param_mut_binding_warning.out
View file

@ -6,17 +6,25 @@
pub struct op_read_sync;
#[doc(hidden)]
impl op_read_sync {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_read_sync)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

63
ops/optimizer_tests/raw_ptr.out
View file

@ -6,29 +6,48 @@
pub struct op_ffi_ptr_of;
#[doc(hidden)]
impl op_ffi_ptr_of {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_ffi_ptr_of)
}
pub fn v8_fn_ptr<'scope, FP>() -> deno_core::v8::FunctionCallback
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope, FP>(
info: *const deno_core::v8::FunctionCallbackInfo,
)
where
FP: FfiPermissions + 'static,
{
use deno_core::v8::MapFnTo;
Self::v8_func::<FP>.map_fn_to()
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func::<FP>(scope, args, rv);
}
pub fn decl<'scope, FP>() -> deno_core::OpDecl
pub const fn decl<'scope, FP>() -> deno_core::OpDecl
where
FP: FfiPermissions + 'static,
{
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr::<FP>(),
v8_fn_ptr: Self::v8_fn_ptr::<FP> as _,
enabled: true,
fast_fn: Some(
Box::new(op_ffi_ptr_of_fast::<FP> {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[
V8Value,
TypedArray(CType::Uint8),
TypedArray(CType::Uint32),
CallbackOptions,
],
CType::Void,
op_ffi_ptr_of_fast_fn::<FP> as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -131,28 +150,6 @@ impl op_ffi_ptr_of {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_ffi_ptr_of_fast<FP> {
_phantom: ::std::marker::PhantomData<FP>,
}
impl<'scope, FP> deno_core::v8::fast_api::FastFunction for op_ffi_ptr_of_fast<FP>
where
FP: FfiPermissions + 'static,
{
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_ffi_ptr_of_fast_fn::<FP> as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, TypedArray(CType::Uint8), TypedArray(CType::Uint32), CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_ffi_ptr_of_fast_fn<'scope, FP>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/serde_v8_value.out
View file

@ -6,23 +6,37 @@
pub struct op_is_proxy;
#[doc(hidden)]
impl op_is_proxy {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_is_proxy)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_is_proxy_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, V8Value],
CType::Bool,
op_is_proxy_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -71,25 +85,6 @@ impl op_is_proxy {
};
}
}
struct op_is_proxy_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_is_proxy_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_is_proxy_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, V8Value]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Bool
}
}
#[allow(clippy::too_many_arguments)]
fn op_is_proxy_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/strings.out
View file

@ -6,23 +6,37 @@
pub struct op_string_length;
#[doc(hidden)]
impl op_string_length {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_string_length)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_string_length_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, SeqOneByteString],
CType::Uint32,
op_string_length_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -72,25 +86,6 @@ impl op_string_length {
};
}
}
struct op_string_length_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_string_length_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_string_length_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, SeqOneByteString]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Uint32
}
}
#[allow(clippy::too_many_arguments)]
fn op_string_length_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

20
ops/optimizer_tests/strings_result.out
View file

@ -6,17 +6,25 @@
pub struct op_string_length;
#[doc(hidden)]
impl op_string_length {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_string_length)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

20
ops/optimizer_tests/u64_result.out
View file

@ -6,17 +6,25 @@
pub struct op_bench_now;
#[doc(hidden)]
impl op_bench_now {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_bench_now)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: None,
is_async: false,

55
ops/optimizer_tests/uint8array.out
View file

@ -6,23 +6,37 @@
pub struct op_import_spki_x25519;
#[doc(hidden)]
impl op_import_spki_x25519 {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_import_spki_x25519)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_import_spki_x25519_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, TypedArray(CType::Uint8), TypedArray(CType::Uint8)],
CType::Bool,
op_import_spki_x25519_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -148,25 +162,6 @@ impl op_import_spki_x25519 {
};
}
}
struct op_import_spki_x25519_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_import_spki_x25519_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_import_spki_x25519_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, TypedArray(CType::Uint8), TypedArray(CType::Uint8)]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Bool
}
}
#[allow(clippy::too_many_arguments)]
fn op_import_spki_x25519_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/unit_result.out
View file

@ -6,23 +6,37 @@
pub struct op_unit_result;
#[doc(hidden)]
impl op_unit_result {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_unit_result)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_unit_result_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, CallbackOptions],
CType::Void,
op_unit_result_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -71,25 +85,6 @@ impl op_unit_result {
};
}
}
struct op_unit_result_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_unit_result_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_unit_result_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_unit_result_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/unit_result2.out
View file

@ -6,23 +6,37 @@
pub struct op_set_nodelay;
#[doc(hidden)]
impl op_set_nodelay {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_set_nodelay)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_set_nodelay_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, Uint32, Bool, CallbackOptions],
CType::Void,
op_set_nodelay_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -104,25 +118,6 @@ impl op_set_nodelay {
};
}
}
struct op_set_nodelay_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_set_nodelay_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_set_nodelay_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, Uint32, Bool, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_set_nodelay_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,

55
ops/optimizer_tests/unit_ret.out
View file

@ -6,23 +6,37 @@
pub struct op_unit;
#[doc(hidden)]
impl op_unit {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_unit)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_unit_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value],
CType::Void,
op_unit_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -60,25 +74,6 @@ impl op_unit {
};
}
}
struct op_unit_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_unit_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_unit_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_unit_fast_fn<'scope>(_: deno_core::v8::Local<deno_core::v8::Object>) -> () {
use deno_core::v8;

55
ops/optimizer_tests/wasm_op.out
View file

@ -6,23 +6,37 @@
pub struct op_wasm;
#[doc(hidden)]
impl op_wasm {
pub fn name() -> &'static str {
pub const fn name() -> &'static str {
stringify!(op_wasm)
}
pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
use deno_core::v8::MapFnTo;
Self::v8_func.map_fn_to()
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub extern "C" fn v8_fn_ptr<'scope>(
info: *const deno_core::v8::FunctionCallbackInfo,
) {
let info = unsafe { &*info };
let scope = &mut unsafe { deno_core::v8::CallbackScope::new(info) };
let args = deno_core::v8::FunctionCallbackArguments::from_function_callback_info(
info,
);
let rv = deno_core::v8::ReturnValue::from_function_callback_info(info);
Self::v8_func(scope, args, rv);
}
pub fn decl<'scope>() -> deno_core::OpDecl {
pub const fn decl<'scope>() -> deno_core::OpDecl {
deno_core::OpDecl {
name: Self::name(),
v8_fn_ptr: Self::v8_fn_ptr(),
v8_fn_ptr: Self::v8_fn_ptr as _,
enabled: true,
fast_fn: Some(
Box::new(op_wasm_fast {
_phantom: ::std::marker::PhantomData,
}),
),
fast_fn: {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
Some(
deno_core::v8::fast_api::FastFunction::new(
&[V8Value, CallbackOptions],
CType::Void,
op_wasm_fast_fn as *const ::std::ffi::c_void,
),
)
},
is_async: false,
is_unstable: false,
is_v8: false,
@ -47,25 +61,6 @@ impl op_wasm {
op_state.tracker.track_sync(ctx.id);
}
}
struct op_wasm_fast {
_phantom: ::std::marker::PhantomData<()>,
}
impl<'scope> deno_core::v8::fast_api::FastFunction for op_wasm_fast {
#[inline(always)]
fn function(&self) -> *const ::std::ffi::c_void {
op_wasm_fast_fn as *const ::std::ffi::c_void
}
#[inline(always)]
fn args(&self) -> &'static [deno_core::v8::fast_api::Type] {
use deno_core::v8::fast_api::Type::*;
use deno_core::v8::fast_api::CType;
&[V8Value, CallbackOptions]
}
#[inline(always)]
fn return_type(&self) -> deno_core::v8::fast_api::CType {
deno_core::v8::fast_api::CType::Void
}
}
#[allow(clippy::too_many_arguments)]
fn op_wasm_fast_fn<'scope>(
_: deno_core::v8::Local<deno_core::v8::Object>,