diff --git a/Cargo.lock b/Cargo.lock
index bb383249c5..66aa8a38f7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5270,9 +5270,9 @@ dependencies = [
 
 [[package]]
 name = "v8"
-version = "0.66.0"
+version = "0.67.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8ab8597b885c17b3761f6ffc29b7a62758612c409285a9271c6dacd17bb745"
+checksum = "c7bf30312144d97d3fb61a0c8893eec02f4fa53ec2b691a8d05da9605ab26024"
 dependencies = [
  "bitflags",
  "fslock",
diff --git a/Cargo.toml b/Cargo.toml
index b8cfa99a1c..e50b763886 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,7 +43,7 @@ license = "MIT"
 repository = "https://github.com/denoland/deno"
 
 [workspace.dependencies]
-v8 = { version = "0.66.0", default-features = false }
+v8 = { version = "0.67.0", default-features = false }
 deno_ast = { version = "0.25.0", features = ["transpiling"] }
 
 deno_core = { version = "0.177.0", path = "./core" }
diff --git a/core/bindings.rs b/core/bindings.rs
index 52db40f0da..00d0cf2e6f 100644
--- a/core/bindings.rs
+++ b/core/bindings.rs
@@ -44,7 +44,7 @@ pub(crate) fn external_references(ops: &[OpCtx]) -> v8::ExternalReferences {
     });
     if let Some(fast_fn) = &ctx.decl.fast_fn {
       references.push(v8::ExternalReference {
-        pointer: fast_fn.function() as _,
+        pointer: fast_fn.function as _,
       });
       references.push(v8::ExternalReference {
         pointer: ctx.fast_fn_c_info.unwrap().as_ptr() as _,
@@ -218,7 +218,7 @@ fn add_op_to_deno_core_ops(
   let templ = if let Some(fast_function) = &op_ctx.decl.fast_fn {
     builder.build_fast(
       scope,
-      &**fast_function,
+      fast_function,
       Some(op_ctx.fast_fn_c_info.unwrap().as_ptr()),
       None,
       None,
diff --git a/core/extensions.rs b/core/extensions.rs
index 9b4fb203a1..ca618c9b73 100644
--- a/core/extensions.rs
+++ b/core/extensions.rs
@@ -72,8 +72,8 @@ pub struct OpDecl {
   pub is_async: bool,
   pub is_unstable: bool,
   pub is_v8: bool,
-  pub fast_fn: Option<Box<dyn FastFunction>>,
   pub force_registration: bool,
+  pub fast_fn: Option<FastFunction>,
 }
 
 impl OpDecl {
diff --git a/core/ops.rs b/core/ops.rs
index 3a276082f9..cceeb56547 100644
--- a/core/ops.rs
+++ b/core/ops.rs
@@ -175,13 +175,13 @@ impl OpCtx {
     let mut fast_fn_c_info = None;
 
     if let Some(fast_fn) = &decl.fast_fn {
-      let args = CTypeInfo::new_from_slice(fast_fn.args());
-      let ret = CTypeInfo::new(fast_fn.return_type());
+      let args = CTypeInfo::new_from_slice(fast_fn.args);
+      let ret = CTypeInfo::new(fast_fn.return_type);
 
       // SAFETY: all arguments are coming from the trait and they have
       // static lifetime
       let c_fn = unsafe {
-        CFunctionInfo::new(args.as_ptr(), fast_fn.args().len(), ret.as_ptr())
+        CFunctionInfo::new(args.as_ptr(), fast_fn.args.len(), ret.as_ptr())
       };
       fast_fn_c_info = Some(c_fn);
     }
diff --git a/core/runtime.rs b/core/runtime.rs
index 787bac9727..bfb4c45cc3 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -793,8 +793,8 @@ impl JsRuntime {
         true => op,
         false => OpDecl {
           v8_fn_ptr: match op.is_async {
-            true => op_void_async::v8_fn_ptr(),
-            false => op_void_sync::v8_fn_ptr(),
+            true => op_void_async::v8_fn_ptr as _,
+            false => op_void_sync::v8_fn_ptr as _,
           },
           ..op
         },
diff --git a/ext/ffi/turbocall.rs b/ext/ffi/turbocall.rs
index 3d01f00f58..f25f9274f9 100644
--- a/ext/ffi/turbocall.rs
+++ b/ext/ffi/turbocall.rs
@@ -40,26 +40,29 @@ pub(crate) fn compile_trampoline(sym: &Symbol) -> Trampoline {
   }
 }
 
-pub(crate) fn make_template(sym: &Symbol, trampoline: &Trampoline) -> Template {
+pub(crate) fn make_template(
+  sym: &Symbol,
+  trampoline: &Trampoline,
+) -> fast_api::FastFunction {
   let mut params = once(fast_api::Type::V8Value) // Receiver
     .chain(sym.parameter_types.iter().map(|t| t.into()))
     .collect::<Vec<_>>();
 
   let ret = if needs_unwrap(&sym.result_type) {
     params.push(fast_api::Type::TypedArray(fast_api::CType::Int32));
-    fast_api::Type::Void
+    fast_api::CType::Void
   } else if sym.result_type == NativeType::Buffer {
     // Buffer can be used as a return type and converts differently than in parameters.
-    fast_api::Type::Pointer
+    fast_api::CType::Pointer
   } else {
-    fast_api::Type::from(&sym.result_type)
+    fast_api::CType::from(&fast_api::Type::from(&sym.result_type))
   };
 
-  Template {
-    args: params.into_boxed_slice(),
-    ret: (&ret).into(),
-    symbol_ptr: trampoline.ptr(),
-  }
+  fast_api::FastFunction::new(
+    Box::leak(params.into_boxed_slice()),
+    ret,
+    trampoline.ptr(),
+  )
 }
 
 /// Trampoline for fast-call FFI functions
@@ -73,26 +76,6 @@ impl Trampoline {
   }
 }
 
-pub(crate) struct Template {
-  pub args: Box<[fast_api::Type]>,
-  pub ret: fast_api::CType,
-  pub symbol_ptr: *const c_void,
-}
-
-impl fast_api::FastFunction for Template {
-  fn function(&self) -> *const c_void {
-    self.symbol_ptr
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    Box::leak(self.args.clone())
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    self.ret
-  }
-}
-
 impl From<&NativeType> for fast_api::Type {
   fn from(native_type: &NativeType) -> Self {
     match native_type {
diff --git a/ext/flash/lib.rs b/ext/flash/lib.rs
index 21686379a4..647358a4f8 100644
--- a/ext/flash/lib.rs
+++ b/ext/flash/lib.rs
@@ -316,26 +316,16 @@ async fn op_flash_write_resource(
   Ok(())
 }
 
-pub struct RespondFast;
-
-impl fast_api::FastFunction for RespondFast {
-  fn function(&self) -> *const c_void {
-    op_flash_respond_fast as *const c_void
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    &[
-      fast_api::Type::V8Value,
-      fast_api::Type::Uint32,
-      fast_api::Type::TypedArray(fast_api::CType::Uint8),
-      fast_api::Type::Bool,
-    ]
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    fast_api::CType::Uint32
-  }
-}
+pub const RESPOND_FAST: fast_api::FastFunction = fast_api::FastFunction::new(
+  &[
+    fast_api::Type::V8Value,
+    fast_api::Type::Uint32,
+    fast_api::Type::TypedArray(fast_api::CType::Uint8),
+    fast_api::Type::Bool,
+  ],
+  fast_api::CType::Uint32,
+  op_flash_respond_fast as *const c_void,
+);
 
 fn flash_respond(
   ctx: &mut ServerContext,
@@ -468,21 +458,11 @@ fn next_request_sync(ctx: &mut ServerContext) -> u32 {
   ctx.next_token - offset
 }
 
-pub struct NextRequestFast;
-
-impl fast_api::FastFunction for NextRequestFast {
-  fn function(&self) -> *const c_void {
-    op_flash_next_fast as *const c_void
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    &[fast_api::Type::V8Value]
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    fast_api::CType::Uint32
-  }
-}
+const NEXT_REQUEST_FAST: fast_api::FastFunction = fast_api::FastFunction::new(
+  &[fast_api::Type::V8Value],
+  fast_api::CType::Uint32,
+  op_flash_next_fast as *const c_void,
+);
 
 unsafe fn op_flash_next_fast(recv: v8::Local<v8::Object>) -> u32 {
   let ptr =
@@ -491,21 +471,11 @@ unsafe fn op_flash_next_fast(recv: v8::Local<v8::Object>) -> u32 {
   next_request_sync(ctx)
 }
 
-pub struct GetMethodFast;
-
-impl fast_api::FastFunction for GetMethodFast {
-  fn function(&self) -> *const c_void {
-    op_flash_get_method_fast as *const c_void
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    &[fast_api::Type::V8Value, fast_api::Type::Uint32]
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    fast_api::CType::Uint32
-  }
-}
+const GET_METHOD_FAST: fast_api::FastFunction = fast_api::FastFunction::new(
+  &[fast_api::Type::V8Value, fast_api::Type::Uint32],
+  fast_api::CType::Uint32,
+  op_flash_get_method_fast as *const c_void,
+);
 
 unsafe fn op_flash_get_method_fast(
   recv: v8::Local<v8::Object>,
@@ -549,7 +519,7 @@ fn op_flash_make_request<'scope>(
     )
     .data(v8::External::new(scope, ctx as *mut _).into());
 
-    let func = builder.build_fast(scope, &NextRequestFast, None, None, None);
+    let func = builder.build_fast(scope, &NEXT_REQUEST_FAST, None, None, None);
     let func: v8::Local<v8::Value> = func.get_function(scope).unwrap().into();
 
     let key = v8::String::new(scope, "nextRequest").unwrap();
@@ -572,7 +542,7 @@ fn op_flash_make_request<'scope>(
     )
     .data(v8::External::new(scope, ctx as *mut _).into());
 
-    let func = builder.build_fast(scope, &GetMethodFast, None, None, None);
+    let func = builder.build_fast(scope, &GET_METHOD_FAST, None, None, None);
     let func: v8::Local<v8::Value> = func.get_function(scope).unwrap().into();
 
     let key = v8::String::new(scope, "getMethod").unwrap();
@@ -610,7 +580,7 @@ fn op_flash_make_request<'scope>(
     )
     .data(v8::External::new(scope, ctx as *mut _).into());
 
-    let func = builder.build_fast(scope, &RespondFast, None, None, None);
+    let func = builder.build_fast(scope, &RESPOND_FAST, None, None, None);
     let func: v8::Local<v8::Value> = func.get_function(scope).unwrap().into();
 
     let key = v8::String::new(scope, "respond").unwrap();
diff --git a/ops/fast_call.rs b/ops/fast_call.rs
index fa5af74b87..2485b6083c 100644
--- a/ops/fast_call.rs
+++ b/ops/fast_call.rs
@@ -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,
diff --git a/ops/lib.rs b/ops/lib.rs
index bd87bc4920..aee6c8c034 100644
--- a/ops/lib.rs
+++ b/ops/lib.rs
@@ -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,
diff --git a/ops/optimizer_tests/async_nop.out b/ops/optimizer_tests/async_nop.out
index 83ffed142b..5d73f23431 100644
--- a/ops/optimizer_tests/async_nop.out
+++ b/ops/optimizer_tests/async_nop.out
@@ -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>,
diff --git a/ops/optimizer_tests/async_result.out b/ops/optimizer_tests/async_result.out
index 111430b77c..f820687cdb 100644
--- a/ops/optimizer_tests/async_result.out
+++ b/ops/optimizer_tests/async_result.out
@@ -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>,
diff --git a/ops/optimizer_tests/callback_options.out b/ops/optimizer_tests/callback_options.out
index 87202f50db..e892e01189 100644
--- a/ops/optimizer_tests/callback_options.out
+++ b/ops/optimizer_tests/callback_options.out
@@ -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>,
diff --git a/ops/optimizer_tests/cow_str.out b/ops/optimizer_tests/cow_str.out
index 89d2f22c48..8ee82078b1 100644
--- a/ops/optimizer_tests/cow_str.out
+++ b/ops/optimizer_tests/cow_str.out
@@ -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>,
diff --git a/ops/optimizer_tests/f64_slice.out b/ops/optimizer_tests/f64_slice.out
index 9d1e1c7e3d..3e8ef07d85 100644
--- a/ops/optimizer_tests/f64_slice.out
+++ b/ops/optimizer_tests/f64_slice.out
@@ -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>,
diff --git a/ops/optimizer_tests/incompatible_1.out b/ops/optimizer_tests/incompatible_1.out
index 4bd26ecccd..5104fb5e46 100644
--- a/ops/optimizer_tests/incompatible_1.out
+++ b/ops/optimizer_tests/incompatible_1.out
@@ -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,
diff --git a/ops/optimizer_tests/issue16934.out b/ops/optimizer_tests/issue16934.out
index 5b0b208f32..f8acf5712a 100644
--- a/ops/optimizer_tests/issue16934.out
+++ b/ops/optimizer_tests/issue16934.out
@@ -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,
diff --git a/ops/optimizer_tests/issue16934_fast.out b/ops/optimizer_tests/issue16934_fast.out
index 704329e4aa..0cdc3eb255 100644
--- a/ops/optimizer_tests/issue16934_fast.out
+++ b/ops/optimizer_tests/issue16934_fast.out
@@ -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,
diff --git a/ops/optimizer_tests/op_blob_revoke_object_url.out b/ops/optimizer_tests/op_blob_revoke_object_url.out
index 83d3e1d04f..4eda692240 100644
--- a/ops/optimizer_tests/op_blob_revoke_object_url.out
+++ b/ops/optimizer_tests/op_blob_revoke_object_url.out
@@ -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,
diff --git a/ops/optimizer_tests/op_ffi_ptr_value.out b/ops/optimizer_tests/op_ffi_ptr_value.out
index d81518e6ef..3fee00cff8 100644
--- a/ops/optimizer_tests/op_ffi_ptr_value.out
+++ b/ops/optimizer_tests/op_ffi_ptr_value.out
@@ -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>,
diff --git a/ops/optimizer_tests/op_print.out b/ops/optimizer_tests/op_print.out
index 38602b3c10..7bf5457d78 100644
--- a/ops/optimizer_tests/op_print.out
+++ b/ops/optimizer_tests/op_print.out
@@ -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,
diff --git a/ops/optimizer_tests/op_state.out b/ops/optimizer_tests/op_state.out
index 98b524d0d8..cebb1e25c7 100644
--- a/ops/optimizer_tests/op_state.out
+++ b/ops/optimizer_tests/op_state.out
@@ -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>,
diff --git a/ops/optimizer_tests/op_state_basic1.out b/ops/optimizer_tests/op_state_basic1.out
index ff5fa2a179..d8278daca6 100644
--- a/ops/optimizer_tests/op_state_basic1.out
+++ b/ops/optimizer_tests/op_state_basic1.out
@@ -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>,
diff --git a/ops/optimizer_tests/op_state_generics.out b/ops/optimizer_tests/op_state_generics.out
index 7c9998af57..631a2142f7 100644
--- a/ops/optimizer_tests/op_state_generics.out
+++ b/ops/optimizer_tests/op_state_generics.out
@@ -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>,
diff --git a/ops/optimizer_tests/op_state_result.out b/ops/optimizer_tests/op_state_result.out
index 30ddf6ff92..d03ffd5a61 100644
--- a/ops/optimizer_tests/op_state_result.out
+++ b/ops/optimizer_tests/op_state_result.out
@@ -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>,
diff --git a/ops/optimizer_tests/op_state_warning.out b/ops/optimizer_tests/op_state_warning.out
index d1148db19c..5548dc134e 100644
--- a/ops/optimizer_tests/op_state_warning.out
+++ b/ops/optimizer_tests/op_state_warning.out
@@ -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>,
diff --git a/ops/optimizer_tests/op_state_with_transforms.out b/ops/optimizer_tests/op_state_with_transforms.out
index a49e3cd0d9..ad4e5335a8 100644
--- a/ops/optimizer_tests/op_state_with_transforms.out
+++ b/ops/optimizer_tests/op_state_with_transforms.out
@@ -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>,
diff --git a/ops/optimizer_tests/opstate_with_arity.out b/ops/optimizer_tests/opstate_with_arity.out
index 7e7595c79a..037774c255 100644
--- a/ops/optimizer_tests/opstate_with_arity.out
+++ b/ops/optimizer_tests/opstate_with_arity.out
@@ -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>,
diff --git a/ops/optimizer_tests/option_arg.out b/ops/optimizer_tests/option_arg.out
index 3790ef4fa6..39d47562b8 100644
--- a/ops/optimizer_tests/option_arg.out
+++ b/ops/optimizer_tests/option_arg.out
@@ -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,
diff --git a/ops/optimizer_tests/owned_string.out b/ops/optimizer_tests/owned_string.out
index 58a952cd76..5b516ac5c2 100644
--- a/ops/optimizer_tests/owned_string.out
+++ b/ops/optimizer_tests/owned_string.out
@@ -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>,
diff --git a/ops/optimizer_tests/param_mut_binding_warning.out b/ops/optimizer_tests/param_mut_binding_warning.out
index 1655ece761..98dc6b2b91 100644
--- a/ops/optimizer_tests/param_mut_binding_warning.out
+++ b/ops/optimizer_tests/param_mut_binding_warning.out
@@ -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,
diff --git a/ops/optimizer_tests/raw_ptr.out b/ops/optimizer_tests/raw_ptr.out
index a1c4ab9875..678ce50152 100644
--- a/ops/optimizer_tests/raw_ptr.out
+++ b/ops/optimizer_tests/raw_ptr.out
@@ -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>,
diff --git a/ops/optimizer_tests/serde_v8_value.out b/ops/optimizer_tests/serde_v8_value.out
index 2a10c00d45..d0f8dacdfc 100644
--- a/ops/optimizer_tests/serde_v8_value.out
+++ b/ops/optimizer_tests/serde_v8_value.out
@@ -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>,
diff --git a/ops/optimizer_tests/strings.out b/ops/optimizer_tests/strings.out
index 6d5fca0a5f..8a72c8cab6 100644
--- a/ops/optimizer_tests/strings.out
+++ b/ops/optimizer_tests/strings.out
@@ -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>,
diff --git a/ops/optimizer_tests/strings_result.out b/ops/optimizer_tests/strings_result.out
index 6ef5963a69..8b2e2acef2 100644
--- a/ops/optimizer_tests/strings_result.out
+++ b/ops/optimizer_tests/strings_result.out
@@ -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,
diff --git a/ops/optimizer_tests/u64_result.out b/ops/optimizer_tests/u64_result.out
index 6744e65acb..02d25686a8 100644
--- a/ops/optimizer_tests/u64_result.out
+++ b/ops/optimizer_tests/u64_result.out
@@ -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,
diff --git a/ops/optimizer_tests/uint8array.out b/ops/optimizer_tests/uint8array.out
index 96980cc040..93fa40e1f2 100644
--- a/ops/optimizer_tests/uint8array.out
+++ b/ops/optimizer_tests/uint8array.out
@@ -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>,
diff --git a/ops/optimizer_tests/unit_result.out b/ops/optimizer_tests/unit_result.out
index 11a862fa5d..354a2e3b94 100644
--- a/ops/optimizer_tests/unit_result.out
+++ b/ops/optimizer_tests/unit_result.out
@@ -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>,
diff --git a/ops/optimizer_tests/unit_result2.out b/ops/optimizer_tests/unit_result2.out
index cadbfdd724..721229121b 100644
--- a/ops/optimizer_tests/unit_result2.out
+++ b/ops/optimizer_tests/unit_result2.out
@@ -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>,
diff --git a/ops/optimizer_tests/unit_ret.out b/ops/optimizer_tests/unit_ret.out
index a1ff75682c..7d0f63dc88 100644
--- a/ops/optimizer_tests/unit_ret.out
+++ b/ops/optimizer_tests/unit_ret.out
@@ -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;
diff --git a/ops/optimizer_tests/wasm_op.out b/ops/optimizer_tests/wasm_op.out
index dcf38d9c7e..0196f45481 100644
--- a/ops/optimizer_tests/wasm_op.out
+++ b/ops/optimizer_tests/wasm_op.out
@@ -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>,