Repository: denoland/deno_core
Pull request #299 (2023-11-02 22:21:46)

chore(ops): remove op1
Farewell, op1!

![bilbo-baggins-ship](https://github.com/denoland/deno_core/assets/512240/7ebd3f41-d83d-42c3-a941-e18d6b12af63)



Patch:
diff --git a/core/benches/ops/sync.rs b/core/benches/ops/sync.rs
index f3b6fc4..8fe76b7 100644
--- a/core/benches/ops/sync.rs
+++ b/core/benches/ops/sync.rs
@@ -16,7 +16,6 @@ deno_core::extension!(
     op_string,
     op_string_onebyte,
     op_string_bytestring,
-    op_string_old,
     op_string_option_u32,
     op_local,
     op_local_scope,
@@ -30,7 +29,6 @@ deno_core::extension!(
     op_bigint_return,
     op_external,
     op_external_nofast,
-    op_buffer_old,
     op_buffer,
     op_buffer_jsbuffer,
     op_buffer_nofast,
@@ -73,11 +71,6 @@ pub fn op_string_bytestring(#[serde] s: ByteString) -> u32 {
   s.len() as _
 }
 
-#[op(fast)]
-pub fn op_string_old(s: &str) -> u32 {
-  s.len() as _
-}
-
 #[op2]
 pub fn op_string_option_u32(#[string] s: &str) -> Option<u32> {
   Some(s.len() as _)
@@ -129,9 +122,6 @@ pub fn op_external(_input: *const c_void) {}
 #[op2(nofast)]
 pub fn op_external_nofast(_input: *const c_void) {}
 
-#[op]
-pub fn op_buffer_old(_buffer: &[u8]) {}
-
 #[op2(fast)]
 pub fn op_buffer(#[buffer] _buffer: &[u8]) {}
 
@@ -318,55 +308,6 @@ fn bench_op_string_large_utf8_1000000(b: &mut Bencher) {
   );
 }
 
-/// A string function with a numeric return value.
-fn bench_op_string_old(b: &mut Bencher) {
-  bench_op(b, BENCH_COUNT, "op_string_old", 1, "accum += op_string_old('this is a reasonably long string that we would like to get the length of!');");
-}
-
-/// A string function with a numeric return value.
-fn bench_op_string_old_large_1000(b: &mut Bencher) {
-  bench_op(
-    b,
-    BENCH_COUNT,
-    "op_string_old",
-    1,
-    "accum += op_string_old(LARGE_STRING_1000);",
-  );
-}
-
-/// A string function with a numeric return value.
-fn bench_op_string_old_large_1000000(b: &mut Bencher) {
-  bench_op(
-    b,
-    LARGE_BENCH_COUNT,
-    "op_string_old",
-    1,
-    "accum += op_string_old(LARGE_STRING_1000000);",
-  );
-}
-
-/// A string function with a numeric return value.
-fn bench_op_string_old_large_utf8_1000(b: &mut Bencher) {
-  bench_op(
-    b,
-    BENCH_COUNT,
-    "op_string_old",
-    1,
-    "accum += op_string_old(LARGE_STRING_UTF8_1000);",
-  );
-}
-
-/// A string function with a numeric return value.
-fn bench_op_string_old_large_utf8_1000000(b: &mut Bencher) {
-  bench_op(
-    b,
-    LARGE_BENCH_COUNT,
-    "op_string_old",
-    1,
-    "accum += op_string_old(LARGE_STRING_UTF8_1000000);",
-  );
-}
-
 /// A string function with an option numeric return value.
 fn bench_op_string_option_u32(b: &mut Bencher) {
   bench_op(b, BENCH_COUNT, "op_string_option_u32", 1, "accum += op_string_option_u32('this is a reasonably long string that we would like to get the length of!');");
@@ -441,10 +382,6 @@ fn bench_op_external_nofast(b: &mut Bencher) {
   );
 }
 
-fn bench_op_buffer_old(b: &mut Bencher) {
-  bench_op(b, BENCH_COUNT, "op_buffer_old", 1, "op_buffer_old(BUFFER)");
-}
-
 fn bench_op_buffer(b: &mut Bencher) {
   bench_op(b, BENCH_COUNT, "op_buffer", 1, "op_buffer(BUFFER)");
 }
@@ -496,11 +433,6 @@ benchmark_group!(
   bench_op_string_onebyte_large_1000000,
   bench_op_string_large_utf8_1000,
   bench_op_string_large_utf8_1000000,
-  bench_op_string_old,
-  bench_op_string_old_large_1000,
-  bench_op_string_old_large_1000000,
-  bench_op_string_old_large_utf8_1000,
-  bench_op_string_old_large_utf8_1000000,
   bench_op_string_option_u32,
   bench_op_v8_local,
   bench_op_v8_local_scope,
@@ -513,7 +445,6 @@ benchmark_group!(
   bench_op_v8_isolate_nofast,
   bench_op_external,
   bench_op_external_nofast,
-  bench_op_buffer_old,
   bench_op_buffer,
   bench_op_buffer_jsbuffer,
   bench_op_buffer_nofast,
diff --git a/core/lib.rs b/core/lib.rs
index b069991..ca22172 100644
--- a/core/lib.rs
+++ b/core/lib.rs
@@ -41,7 +41,6 @@ pub use sourcemap;
 pub use url;
 pub use v8;
 
-pub use deno_ops::op;
 pub use deno_ops::op2;
 
 pub use crate::async_cancel::CancelFuture;
diff --git a/core/ops.rs b/core/ops.rs
index 708f7bd..f4b9390 100644
--- a/core/ops.rs
+++ b/core/ops.rs
@@ -248,7 +248,6 @@ impl OpCtx {
 pub struct OpState {
   pub resource_table: ResourceTable,
   pub tracker: OpsTracker,
-  pub last_fast_op_error: Option<AnyError>,
   pub(crate) gotham_state: GothamState,
   pub waker: Arc<AtomicWaker>,
   pub feature_checker: Arc<FeatureChecker>,
@@ -262,7 +261,6 @@ impl OpState {
     OpState {
       resource_table: Default::default(),
       gotham_state: Default::default(),
-      last_fast_op_error: None,
       tracker: OpsTracker::new(ops_count),
       waker: Arc::new(AtomicWaker::new()),
       feature_checker: maybe_feature_checker.unwrap_or_default(),
diff --git a/ops/attrs.rs b/ops/attrs.rs
deleted file mode 100644
index d0182fc..0000000
--- a/ops/attrs.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-use syn::parse::Parse;
-use syn::parse::ParseStream;
-use syn::Error;
-use syn::Ident;
-use syn::Result;
-use syn::Token;
-
-#[derive(Clone, Debug, Default)]
-pub struct Attributes {
-  pub is_unstable: bool,
-  pub is_v8: bool,
-  pub must_be_fast: bool,
-  pub deferred: bool,
-  pub is_wasm: bool,
-  pub relation: Option<Ident>,
-}
-
-impl Parse for Attributes {
-  fn parse(input: ParseStream) -> Result<Self> {
-    let mut self_ = Self::default();
-    let mut fast = false;
-    while let Ok(v) = input.parse::<Ident>() {
-      match v.to_string().as_str() {
-        "unstable" => self_.is_unstable = true,
-        "v8" => self_.is_v8 = true,
-        "fast" => fast = true,
-        "deferred" => self_.deferred = true,
-        "wasm" => self_.is_wasm = true,
-        "slow" => {
-          if !fast {
-            return Err(Error::new(
-              input.span(),
-              "relational attributes can only be used with fast attribute",
-            ));
-          }
-          input.parse::<Token![=]>()?;
-          self_.relation = Some(input.parse()?);
-        }
-        _ => {
-          return Err(Error::new(
-             input.span(),
-            "invalid attribute, expected one of: unstable, v8, fast, deferred, wasm",
-            ));
-        }
-      };
-      let _ = input.parse::<Token![,]>();
-    }
-
-    self_.must_be_fast = self_.is_wasm || fast;
-
-    Ok(self_)
-  }
-}
diff --git a/ops/deno.rs b/ops/deno.rs
deleted file mode 100644
index fbaf2a9..0000000
--- a/ops/deno.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-#![cfg(not(test))]
-
-use proc_macro2::Span;
-use proc_macro2::TokenStream;
-use proc_macro_crate::crate_name;
-use proc_macro_crate::FoundCrate;
-use quote::quote;
-use syn::Ident;
-
-/// Identifier to the `deno_core` crate.
-///
-/// If macro called in deno_core, `crate` is used.
-/// If macro called outside deno_core, `deno_core` OR the renamed
-/// version from Cargo.toml is used.
-pub(crate) fn import() -> TokenStream {
-  let found_crate =
-    crate_name("deno_core").expect("deno_core not present in `Cargo.toml`");
-
-  match found_crate {
-    FoundCrate::Itself => {
-      // TODO(@littledivy): This won't work for `deno_core` examples
-      // since `crate` does not refer to `deno_core`.
-      // examples must re-export deno_core to make this work
-      // until Span inspection APIs are stabilized.
-      //
-      // https://github.com/rust-lang/rust/issues/54725
-      quote!(crate)
-    }
-    FoundCrate::Name(name) => {
-      let ident = Ident::new(&name, Span::call_site());
-      quote!(#ident)
-    }
-  }
-}
diff --git a/ops/fast_call.rs b/ops/fast_call.rs
deleted file mode 100644
index 503eced..0000000
--- a/ops/fast_call.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-//! Code generation for V8 fast calls.
-
-use pmutil::q;
-use pmutil::Quote;
-use pmutil::ToTokensExt;
-use proc_macro2::Span;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::parse_quote;
-use syn::punctuated::Punctuated;
-use syn::token::Comma;
-use syn::Generics;
-use syn::Ident;
-use syn::ItemFn;
-
-use crate::optimizer::FastValue;
-use crate::optimizer::Optimizer;
-
-pub(crate) struct FastImplItems {
-  pub(crate) impl_and_fn: TokenStream,
-  pub(crate) decl: TokenStream,
-  pub(crate) active: bool,
-}
-
-pub(crate) fn generate(
-  core: &TokenStream,
-  optimizer: &mut Optimizer,
-  item_fn: &ItemFn,
-) -> FastImplItems {
-  if !optimizer.fast_compatible {
-    return FastImplItems {
-      impl_and_fn: TokenStream::new(),
-      decl: quote! { None },
-      active: false,
-    };
-  }
-
-  // TODO(@littledivy): Use `let..else` on 1.65.0
-  let output_ty = match &optimizer.fast_result {
-    // Assert that the optimizer did not set a return type.
-    Some(ty) => ty,
-    None => {
-      return FastImplItems {
-        impl_and_fn: TokenStream::new(),
-        decl: quote! { None },
-        active: false,
-      }
-    }
-  };
-
-  // We've got 2 idents.
-  //
-  // - op_foo, the public op declaration contains the user function.
-  // - op_foo_fast_fn, the fast call function.
-  let ident = item_fn.sig.ident.clone();
-  let fast_fn_ident =
-    Ident::new(&format!("{ident}_fast_fn"), Span::call_site());
-
-  // Deal with generics.
-  let generics = &item_fn.sig.generics;
-  let (impl_generics, _, where_clause) = generics.split_for_impl();
-
-  // 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,
-  //   });
-  // }
-
-  // Original inputs.
-  let mut inputs = item_fn.sig.inputs.clone();
-  let mut transforms = q!({});
-  let mut pre_transforms = q!({});
-
-  // Apply parameter transforms
-  for (index, input) in inputs.iter_mut().enumerate() {
-    if let Some(transform) = optimizer.transforms.get(&index) {
-      let quo: Quote = transform.apply_for_fast_call(core, input);
-      transforms.push_tokens(&quo);
-    }
-  }
-
-  // Collect idents to be passed into function call, we can now freely
-  // modify the inputs.
-  let idents = inputs
-    .iter()
-    .map(|input| match input {
-      syn::FnArg::Typed(pat_type) => match &*pat_type.pat {
-        syn::Pat::Ident(pat_ident) => pat_ident.ident.clone(),
-        _ => panic!("unexpected pattern"),
-      },
-      _ => panic!("unexpected argument"),
-    })
-    .collect::<Punctuated<_, Comma>>();
-
-  // Retain only *pure* parameters.
-  let mut fast_fn_inputs = if optimizer.has_opstate_in_parameters() {
-    inputs.into_iter().skip(1).collect()
-  } else {
-    inputs
-  };
-
-  let mut input_variants = optimizer
-    .fast_parameters
-    .iter()
-    .map(q_fast_ty_variant)
-    .collect::<Punctuated<_, Comma>>();
-
-  // Apply *hard* optimizer hints.
-  if optimizer.has_fast_callback_option
-    || optimizer.has_wasm_memory
-    || optimizer.needs_opstate()
-    || optimizer.needs_fast_callback_option
-  {
-    let decl = parse_quote! {
-      fast_api_callback_options: *mut #core::v8::fast_api::FastApiCallbackOptions
-    };
-
-    if optimizer.has_fast_callback_option || optimizer.has_wasm_memory {
-      // Replace last parameter.
-      assert!(fast_fn_inputs.pop().is_some());
-      fast_fn_inputs.push(decl);
-    } else {
-      fast_fn_inputs.push(decl);
-    }
-
-    input_variants.push(q!({ CallbackOptions }));
-  }
-
-  let mut output_transforms = q!({});
-
-  if optimizer.needs_opstate()
-    || optimizer.has_fast_callback_option
-    || optimizer.has_wasm_memory
-  {
-    // Dark arts 🪄 ✨
-    //
-    // - V8 calling convention guarantees that the callback options pointer is non-null.
-    // - `data` union is always initialized as the `v8::Local<v8::Value>` variant.
-    // - deno_core guarantees that `data` is a v8 External pointing to an OpCtx for the
-    //   isolate's lifetime.
-    let prelude = q!({
-      let __opts: &mut v8::fast_api::FastApiCallbackOptions =
-        unsafe { &mut *fast_api_callback_options };
-    });
-
-    pre_transforms.push_tokens(&prelude);
-  }
-
-  if optimizer.needs_opstate() {
-    // Grab the op_state identifier, the first one. ¯\_(ツ)_/¯
-    let op_state = match idents.first() {
-      Some(ident) if optimizer.has_opstate_in_parameters() => ident.clone(),
-      // fn op_foo() -> Result<...>
-      _ => Ident::new("op_state", Span::call_site()),
-    };
-
-    let ctx = q!({
-      let __ctx = unsafe {
-        &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-          as *const _ops::OpCtx)
-      };
-    });
-
-    pre_transforms.push_tokens(&ctx);
-    pre_transforms.push_tokens(&q!(
-      Vars {
-        op_state: &op_state
-      },
-      {
-        let op_state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-      }
-    ));
-
-    if optimizer.returns_result {
-      // Magic fallback 🪄
-      //
-      // If Result<T, E> is Ok(T), return T as fast value.
-      //
-      // Err(E) gets put into `last_fast_op_error` slot and
-      //
-      // V8 calls the slow path so we can take the slot
-      // value and throw.
-      let default = optimizer.fast_result.as_ref().unwrap().default_value();
-      let result_wrap = q!(Vars { op_state, default }, {
-        match result {
-          Ok(result) => result,
-          Err(err) => {
-            op_state.last_fast_op_error.replace(err);
-            __opts.fallback = true;
-            default
-          }
-        }
-      });
-
-      output_transforms.push_tokens(&result_wrap);
-    }
-  }
-
-  if !optimizer.returns_result {
-    let default_output = q!({ result });
-    output_transforms.push_tokens(&default_output);
-  }
-
-  let output = q_fast_ty(output_ty);
-  // Generate the function body.
-  //
-  // fn f <S> (_: Local<Object>, a: T, b: U) -> R {
-  //   /* Transforms */
-  //   let a = a.into();
-  //   let b = b.into();
-  //
-  //   let r = op::call(a, b);
-  //
-  //   /* Return transform */
-  //   r.into()
-  // }
-  let fast_fn = q!(
-    Vars { core, pre_transforms, op_name_fast: &fast_fn_ident, op_name: &ident, fast_fn_inputs, generics, where_clause, idents, transforms, output_transforms, output: &output },
-    {
-      impl generics op_name generics where_clause {
-        #[allow(clippy::too_many_arguments)]
-        fn op_name_fast (_: core::v8::Local<core::v8::Object>, fast_fn_inputs) -> output {
-          use core::v8;
-          use core::_ops;
-          pre_transforms
-          transforms
-          let result = Self::call (idents);
-          output_transforms
-        }
-      }
-    }
-  );
-
-  let output_variant = q_fast_ty_variant(output_ty);
-  let mut generics: Generics = parse_quote! { #impl_generics };
-  generics.where_clause = where_clause.cloned();
-
-  // fast_api::FastFunction::new(&[ CType::T, CType::U ], CType::T, f::<P> as *const ::std::ffi::c_void)
-  let decl = q!(
-    Vars {
-      core: core,
-      fast_fn_ident: fast_fn_ident,
-      inputs: input_variants,
-      output: output_variant
-    },
-    {
-      {
-        use core::v8::fast_api::CType;
-        use core::v8::fast_api::Type::*;
-        Some(core::v8::fast_api::FastFunction::new(
-          &[inputs],
-          CType::output,
-          Self::fast_fn_ident as *const ::std::ffi::c_void,
-        ))
-      }
-    }
-  )
-  .dump();
-
-  let impl_and_fn = fast_fn.dump();
-
-  FastImplItems {
-    impl_and_fn,
-    decl,
-    active: true,
-  }
-}
-
-/// Quote fast value type.
-fn q_fast_ty(v: &FastValue) -> Quote {
-  match v {
-    FastValue::Void => q!({ () }),
-    FastValue::Bool => q!({ bool }),
-    FastValue::U32 => q!({ u32 }),
-    FastValue::I32 => q!({ i32 }),
-    FastValue::U64 => q!({ u64 }),
-    FastValue::I64 => q!({ i64 }),
-    FastValue::F32 => q!({ f32 }),
-    FastValue::F64 => q!({ f64 }),
-    FastValue::Pointer => q!({ *mut ::std::ffi::c_void }),
-    FastValue::V8Value => q!({ v8::Local<v8::Value> }),
-    FastValue::Uint8Array
-    | FastValue::Uint32Array
-    | FastValue::Float64Array
-    | FastValue::SeqOneByteString => unreachable!(),
-  }
-}
-
-/// Quote fast value type's variant.
-fn q_fast_ty_variant(v: &FastValue) -> Quote {
-  match v {
-    FastValue::Void => q!({ Void }),
-    FastValue::Bool => q!({ Bool }),
-    FastValue::U32 => q!({ Uint32 }),
-    FastValue::I32 => q!({ Int32 }),
-    FastValue::U64 => q!({ Uint64 }),
-    FastValue::I64 => q!({ Int64 }),
-    FastValue::F32 => q!({ Float32 }),
-    FastValue::F64 => q!({ Float64 }),
-    FastValue::Pointer => q!({ Pointer }),
-    FastValue::V8Value => q!({ V8Value }),
-    FastValue::Uint8Array => q!({ TypedArray(CType::Uint8) }),
-    FastValue::Uint32Array => q!({ TypedArray(CType::Uint32) }),
-    FastValue::Float64Array => q!({ TypedArray(CType::Float64) }),
-    FastValue::SeqOneByteString => q!({ SeqOneByteString }),
-  }
-}
diff --git a/ops/lib.rs b/ops/lib.rs
index a6d299a..a13f2b4 100644
--- a/ops/lib.rs
+++ b/ops/lib.rs
@@ -1,249 +1,10 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 #![doc = include_str!("README.md")]
 
-use attrs::Attributes;
-use optimizer::BailoutReason;
-use optimizer::Optimizer;
 use proc_macro::TokenStream;
-use proc_macro2::Span;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use quote::ToTokens;
 use std::error::Error;
-use syn::parse;
-use syn::parse_macro_input;
-use syn::punctuated::Punctuated;
-use syn::token::Comma;
-use syn::FnArg;
-use syn::GenericParam;
-use syn::Ident;
-use syn::ItemFn;
-use syn::Lifetime;
-use syn::LifetimeParam;
 
-mod attrs;
-mod deno;
-mod fast_call;
 mod op2;
-mod optimizer;
-
-const SCOPE_LIFETIME: &str = "'scope";
-
-/// Add the 'scope lifetime to the function signature.
-fn add_scope_lifetime(func: &mut ItemFn) {
-  let span = Span::call_site();
-  let lifetime = LifetimeParam::new(Lifetime::new(SCOPE_LIFETIME, span));
-  let generics = &mut func.sig.generics;
-  if !generics.lifetimes().any(|def| *def == lifetime) {
-    generics.params.push(GenericParam::Lifetime(lifetime));
-  }
-}
-
-struct Op {
-  orig: ItemFn,
-  item: ItemFn,
-  // optimizer: Optimizer,
-  core: TokenStream2,
-  attrs: Attributes,
-}
-
-impl Op {
-  fn new(item: ItemFn, attrs: Attributes) -> Self {
-    // Preserve the original function. Change the name to `call`.
-    //
-    // impl op_foo {
-    //   fn call() {}
-    //   ...
-    // }
-    let mut orig = item.clone();
-    orig.sig.ident = Ident::new("call", Span::call_site());
-
-    let is_async = item.sig.asyncness.is_some() || is_future(&item.sig.output);
-    if is_async {
-      panic!("op(async) is no longer supported. Use op2(async)");
-    };
-    let scope_params = exclude_non_lifetime_params(&item.sig.generics.params);
-    orig.sig.generics.params = scope_params;
-    orig.sig.generics.where_clause.take();
-    add_scope_lifetime(&mut orig);
-
-    #[cfg(test)]
-    let core = quote!(deno_core);
-    #[cfg(not(test))]
-    let core = deno::import();
-
-    Self {
-      orig,
-      item,
-      core,
-      attrs,
-    }
-  }
-
-  fn gen(mut self) -> TokenStream2 {
-    let mut optimizer = Optimizer::new();
-    match optimizer.analyze(&mut self) {
-      Err(BailoutReason::MustBeSingleSegment)
-      | Err(BailoutReason::FastUnsupportedParamType) => {
-        optimizer.fast_compatible = false;
-      }
-      _ => {}
-    };
-
-    let Self {
-      core,
-      item,
-      orig,
-      attrs,
-    } = self;
-    let name = &item.sig.ident;
-
-    // TODO(mmastrac): this code is a little awkward but eventually it'll disappear in favour of op2
-    let mut generics = item.sig.generics.clone();
-    generics.where_clause.take();
-    generics.params = exclude_lifetime_params(&generics.params);
-    let params = &generics.params.iter().collect::<Vec<_>>();
-    let where_clause = &item.sig.generics.where_clause;
-
-    // First generate fast call bindings to opt-in to error handling in slow call
-    let fast_call::FastImplItems {
-      impl_and_fn,
-      decl,
-      active,
-    } = fast_call::generate(&core, &mut optimizer, &item);
-
-    let docline = format!("Use `{name}::decl()` to get an op-declaration");
-
-    let is_v8 = attrs.is_v8;
-    let is_unstable = attrs.is_unstable;
-
-    if let Some(v8_fn) = attrs.relation {
-      return quote! {
-        #[allow(non_camel_case_types)]
-        #[doc="Auto-generated by `deno_ops`, i.e: `#[op]`"]
-        #[doc=""]
-        #[doc=#docline]
-        #[doc="you can include in a `deno_core::Extension`."]
-        #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-        pub struct #name #generics {
-          _phantom_data: ::std::marker::PhantomData<(#(#params),*)>
-        }
-
-        impl #generics #core::_ops::Op for #name #generics #where_clause {
-          const NAME: &'static str = stringify!(#name);
-          const DECL: #core::OpDecl = #core::_ops::OpDecl::new_internal(
-            Self::name(),
-            false,
-            #is_unstable,
-            #is_v8,
-            // TODO(mmastrac)
-            /*arg_count*/ 0,
-            /*slow*/ #v8_fn::v8_fn_ptr as _,
-            /*fast*/ #decl,
-          );
-        }
-
-        #[doc(hidden)]
-        impl #generics #name #generics #where_clause {
-          pub const fn name() -> &'static str {
-            stringify!(#name)
-          }
-
-          #[deprecated(note = "Use the const op::DECL instead")]
-          pub const fn decl() -> #core::_ops::OpDecl {
-            <Self as #core::_ops::Op>::DECL
-          }
-
-          #[inline]
-          #[allow(clippy::too_many_arguments)]
-          #[allow(clippy::extra_unused_lifetimes)]
-          #orig
-        }
-
-        #impl_and_fn
-      };
-    }
-
-    let has_fallible_fast_call = active && optimizer.returns_result;
-
-    let (v8_body, arg_count) =
-      codegen_v8_sync(&core, &item, attrs, has_fallible_fast_call);
-
-    // Generate wrapper
-    quote! {
-      #[allow(non_camel_case_types)]
-      #[doc="Auto-generated by `deno_ops`, i.e: `#[op]`"]
-      #[doc=""]
-      #[doc=#docline]
-      #[doc="you can include in a `deno_core::Extension`."]
-      pub struct #name #generics {
-        _phantom_data: ::std::marker::PhantomData<(#(#params),*)>
-      }
-
-      impl #generics #core::_ops::Op for #name #generics #where_clause {
-        #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-        const NAME: &'static str = stringify!(#name);
-        #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-        const DECL: #core::OpDecl = #core::_ops::OpDecl::new_internal(
-          Self::name(),
-          false,
-          #is_unstable,
-          #is_v8,
-          #arg_count as u8,
-          /*slow*/ Self::v8_fn_ptr as _,
-          /*fast*/ #decl,
-        );
-      }
-
-      #[doc(hidden)]
-      impl #generics #name #generics #where_clause {
-        #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-        pub const fn name() -> &'static str {
-          stringify!(#name)
-        }
-
-        #[allow(clippy::not_unsafe_ptr_arg_deref)]
-        pub extern "C" fn v8_fn_ptr (info: *const #core::v8::FunctionCallbackInfo) {
-          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(scope, args, rv);
-        }
-
-        #[deprecated(note = "Use the const op::DECL instead")]
-        pub const fn decl() -> #core::_ops::OpDecl {
-          <Self as #core::_ops::Op>::DECL
-        }
-
-        #[inline]
-        #[allow(clippy::too_many_arguments)]
-        #[allow(clippy::extra_unused_lifetimes)]
-        #orig
-
-        pub fn v8_func<'scope>(
-          scope: &mut #core::v8::HandleScope<'scope>,
-          args: #core::v8::FunctionCallbackArguments,
-          mut rv: #core::v8::ReturnValue,
-        ) {
-          #v8_body
-        }
-      }
-
-      #impl_and_fn
-    }
-  }
-}
-
-/// Deprecated. Use [`macro@op2`].
-#[doc = include_str!("op1.md")]
-#[proc_macro_attribute]
-pub fn op(attr: TokenStream, item: TokenStream) -> TokenStream {
-  let margs = parse_macro_input!(attr as Attributes);
-  let func = parse::<ItemFn>(item).expect("expected a function");
-  let op = Op::new(func, margs);
-  op.gen().into()
-}
 
 /// A macro designed to provide an extremely fast V8->Rust interface layer.
 #[doc = include_str!("op2/README.md")]
@@ -270,619 +31,3 @@ fn op2_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
     }
   }
 }
-
-fn scope_arg(arg: &FnArg) -> Option<TokenStream2> {
-  if is_handle_scope(arg) {
-    Some(quote! { scope, })
-  } else {
-    None
-  }
-}
-
-fn opstate_arg(arg: &FnArg) -> Option<TokenStream2> {
-  match arg {
-    arg if is_rc_refcell_opstate(arg) => Some(quote! { ctx.state.clone(), }),
-    arg if is_mut_ref_opstate(arg) => {
-      Some(quote! { &mut ::std::cell::RefCell::borrow_mut(&ctx.state), })
-    }
-    _ => None,
-  }
-}
-
-/// Generate the body of a v8 func for a sync op
-fn codegen_v8_sync(
-  core: &TokenStream2,
-  f: &syn::ItemFn,
-  margs: Attributes,
-  has_fallible_fast_call: bool,
-) -> (TokenStream2, usize) {
-  let Attributes { is_v8, .. } = margs;
-  let special_args = f
-    .sig
-    .inputs
-    .iter()
-    .map_while(|a| {
-      (if is_v8 { scope_arg(a) } else { None }).or_else(|| opstate_arg(a))
-    })
-    .collect::<Vec<_>>();
-  let rust_i0 = special_args.len();
-  let args_head = special_args.into_iter().collect::<TokenStream2>();
-  let (arg_decls, args_tail, _) = codegen_args(core, f, rust_i0, 0, false);
-  let ret = codegen_sync_ret(core, &f.sig.output);
-
-  let fast_error_handler = if has_fallible_fast_call {
-    quote! {
-      {
-        let op_state = &mut ::std::cell::RefCell::borrow_mut(&ctx.state);
-        if let Some(err) = op_state.last_fast_op_error.take() {
-          let exception = #core::error::to_v8_error(scope, ctx.get_error_class_fn, &err);
-          scope.throw_exception(exception);
-          return;
-        }
-      }
-    }
-  } else {
-    quote! {}
-  };
-
-  let token_stream = quote! {
-    // SAFETY: #core guarantees args.data() is a v8 External pointing to an OpCtx for the isolates lifetime
-    let ctx = unsafe {
-      &*(#core::v8::Local::<#core::v8::External>::cast(args.data()).value()
-      as *const #core::_ops::OpCtx)
-    };
-
-    #fast_error_handler
-    #arg_decls
-
-    let result = Self::call(#args_head #args_tail);
-
-    // use RefCell::borrow instead of state.borrow to avoid clash with std::borrow::Borrow
-    let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-    op_state.tracker.track_sync(ctx.id);
-
-    #ret
-  };
-
-  (token_stream, f.sig.inputs.len() - rust_i0)
-}
-
-/// (full declarations, idents, v8 argument count)
-type ArgumentDecl = (TokenStream2, TokenStream2, usize);
-
-fn codegen_args(
-  core: &TokenStream2,
-  f: &syn::ItemFn,
-  rust_i0: usize, // Index of first generic arg in rust
-  v8_i0: usize,   // Index of first generic arg in v8/js
-  asyncness: bool,
-) -> ArgumentDecl {
-  let inputs = &f.sig.inputs.iter().skip(rust_i0).enumerate();
-  let ident_seq: TokenStream2 = inputs
-    .clone()
-    .map(|(i, _)| format!("arg_{i}"))
-    .collect::<Vec<_>>()
-    .join(", ")
-    .parse()
-    .unwrap();
-  let decls: TokenStream2 = inputs
-    .clone()
-    .map(|(i, arg)| {
-      codegen_arg(core, arg, format!("arg_{i}").as_ref(), v8_i0 + i, asyncness)
-    })
-    .collect();
-  (decls, ident_seq, inputs.len())
-}
-
-fn codegen_arg(
-  core: &TokenStream2,
-  arg: &syn::FnArg,
-  name: &str,
-  idx: usize,
-  asyncness: bool,
-) -> TokenStream2 {
-  let ident = quote::format_ident!("{name}");
-  let (pat, ty) = match arg {
-    syn::FnArg::Typed(pat) => {
-      if is_optional_fast_callback_option(&pat.ty)
-        || is_optional_wasm_memory(&pat.ty)
-      {
-        return quote! { let #ident = None; };
-      }
-      (&pat.pat, &pat.ty)
-    }
-    _ => unreachable!(),
-  };
-  // Fast path if arg should be skipped
-  if matches!(**pat, syn::Pat::Wild(_)) {
-    return quote! { let #ident = (); };
-  }
-  // Fast path for `String`
-  if let Some(is_ref) = is_string(&**ty) {
-    let ref_block = if is_ref {
-      quote! { let #ident = #ident.as_ref(); }
-    } else {
-      quote! {}
-    };
-    return quote! {
-      let #ident = match #core::v8::Local::<#core::v8::String>::try_from(args.get(#idx as i32)) {
-        Ok(v8_string) => #core::serde_v8::to_utf8(v8_string, scope),
-        Err(_) => {
-          return #core::_ops::throw_type_error(scope, format!("Expected string at position {}", #idx));
-        }
-      };
-      #ref_block
-    };
-  }
-  // Fast path for `Cow<'_, str>`
-  if is_cow_str(&**ty) {
-    return quote! {
-      let #ident = match #core::v8::Local::<#core::v8::String>::try_from(args.get(#idx as i32)) {
-        Ok(v8_string) => ::std::borrow::Cow::Owned(#core::serde_v8::to_utf8(v8_string, scope)),
-        Err(_) => {
-          return #core::_ops::throw_type_error(scope, format!("Expected string at position {}", #idx));
-        }
-      };
-    };
-  }
-  // Fast path for `Option<String>`
-  if is_option_string(&**ty) {
-    return quote! {
-      let #ident = match #core::v8::Local::<#core::v8::String>::try_from(args.get(#idx as i32)) {
-        Ok(v8_string) => Some(#core::serde_v8::to_utf8(v8_string, scope)),
-        Err(_) => None
-      };
-    };
-  }
-  // Fast path for &/&mut [u8] and &/&mut [u32]
-  match is_ref_slice(&**ty) {
-    None => {}
-    Some(SliceType::U32Mut) => {
-      assert!(!asyncness, "Memory slices are not allowed in async ops");
-      let blck = codegen_u32_mut_slice(core, idx);
-      return quote! {
-        let #ident = #blck;
-      };
-    }
-    Some(SliceType::F64Mut) => {
-      assert!(!asyncness, "Memory slices are not allowed in async ops");
-      let blck = codegen_f64_mut_slice(core, idx);
-      return quote! {
-        let #ident = #blck;
-      };
-    }
-    Some(_) => {
-      assert!(!asyncness, "Memory slices are not allowed in async ops");
-      let blck = codegen_u8_slice(core, idx);
-      return quote! {
-        let #ident = #blck;
-      };
-    }
-  }
-  // Fast path for `*const u8`
-  if is_ptr_u8(&**ty) {
-    let blk = codegen_u8_ptr(core, idx);
-    return quote! {
-      let #ident = #blk;
-    };
-  }
-  // Fast path for `*const c_void` and `*mut c_void`
-  if is_ptr_cvoid(&**ty) {
-    let blk = codegen_cvoid_ptr(core, idx);
-    return quote! {
-      let #ident = #blk;
-    };
-  }
-  // Otherwise deserialize it via serde_v8
-  quote! {
-    let #ident = args.get(#idx as i32);
-    let #ident = match #core::serde_v8::from_v8(scope, #ident) {
-      Ok(v) => v,
-      Err(err) => {
-        let msg = format!("Error parsing args at position {}: {}", #idx, #core::anyhow::Error::from(err));
-        return #core::_ops::throw_type_error(scope, msg);
-      }
-    };
-  }
-}
-
-fn codegen_u8_slice(core: &TokenStream2, idx: usize) -> TokenStream2 {
-  quote! {{
-    let value = args.get(#idx as i32);
-    match #core::v8::Local::<#core::v8::ArrayBuffer>::try_from(value) {
-      Ok(b) => {
-        let byte_length = b.byte_length();
-        if let Some(data) = b.data() {
-          let store = data.cast::<u8>().as_ptr();
-          // SAFETY: rust guarantees that lifetime of slice is no longer than the call.
-          unsafe { ::std::slice::from_raw_parts_mut(store, byte_length) }
-        } else {
-          &mut []
-        }
-      },
-      Err(_) => {
-        if let Ok(view) = #core::v8::Local::<#core::v8::ArrayBufferView>::try_from(value) {
-          let len = view.byte_length();
-          let offset = view.byte_offset();
-          let buffer = match view.buffer(scope) {
-              Some(v) => v,
-              None => {
-                return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
-              }
-          };
-          if let Some(data) = buffer.data() {
-            let store = data.cast::<u8>().as_ptr();
-            // SAFETY: rust guarantees that lifetime of slice is no longer than the call.
-            unsafe { ::std::slice::from_raw_parts_mut(store.add(offset), len) }
-          } else {
-            &mut []
-          }
-        } else {
-          return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
-        }
-      }
-    }}
-  }
-}
-
-fn codegen_u8_ptr(core: &TokenStream2, idx: usize) -> TokenStream2 {
-  quote! {{
-    let value = args.get(#idx as i32);
-    match #core::v8::Local::<#core::v8::ArrayBuffer>::try_from(value) {
-      Ok(b) => {
-        if let Some(data) = b.data() {
-          data.cast::<u8>().as_ptr()
-        } else {
-          std::ptr::null::<u8>()
-        }
-      },
-      Err(_) => {
-        if let Ok(view) = #core::v8::Local::<#core::v8::ArrayBufferView>::try_from(value) {
-          let offset = view.byte_offset();
-          let buffer = match view.buffer(scope) {
-              Some(v) => v,
-              None => {
-                return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
-              }
-          };
-          let store = if let Some(data) = buffer.data() {
-            data.cast::<u8>().as_ptr()
-          } else {
-            std::ptr::null_mut::<u8>()
-          };
-          unsafe { store.add(offset) }
-        } else {
-          return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
-        }
-      }
-    }
-  }}
-}
-
-fn codegen_cvoid_ptr(core: &TokenStream2, idx: usize) -> TokenStream2 {
-  quote! {{
-    let value = args.get(#idx as i32);
-    if value.is_null() {
-      std::ptr::null_mut()
-    } else if let Ok(b) = #core::v8::Local::<#core::v8::External>::try_from(value) {
-      b.value()
-    } else {
-      return #core::_ops::throw_type_error(scope, format!("Expected External at position {}", #idx));
-    }
-  }}
-}
-
-fn codegen_u32_mut_slice(core: &TokenStream2, idx: usize) -> TokenStream2 {
-  quote! {
-    if let Ok(view) = #core::v8::Local::<#core::v8::Uint32Array>::try_from(args.get(#idx as i32)) {
-      let (offset, len) = (view.byte_offset(), view.byte_length());
-      let buffer = match view.buffer(scope) {
-          Some(v) => v,
-          None => {
-            return #core::_ops::throw_type_error(scope, format!("Expected Uint32Array at position {}", #idx));
-          }
-      };
-      if let Some(data) = buffer.data() {
-        let store = data.cast::<u8>().as_ptr();
-        // SAFETY: buffer from Uint32Array. Rust guarantees that lifetime of slice is no longer than the call.
-        unsafe { ::std::slice::from_raw_parts_mut(store.add(offset) as *mut u32, len / 4) }
-      } else {
-        &mut []
-      }
-    } else {
-      return #core::_ops::throw_type_error(scope, format!("Expected Uint32Array at position {}", #idx));
-    }
-  }
-}
-
-fn codegen_f64_mut_slice(core: &TokenStream2, idx: usize) -> TokenStream2 {
-  quote! {
-    if let Ok(view) = #core::v8::Local::<#core::v8::Float64Array>::try_from(args.get(#idx as i32)) {
-      let (offset, len) = (view.byte_offset(), view.byte_length());
-      let buffer = match view.buffer(scope) {
-          Some(v) => v,
-          None => {
-            return #core::_ops::throw_type_error(scope, format!("Expected Float64Array at position {}", #idx));
-          }
-      };
-      if let Some(data) = buffer.data() {
-        let store = data.cast::<u8>().as_ptr();
-        unsafe { ::std::slice::from_raw_parts_mut(store.add(offset) as *mut f64, len / 8) }
-      } else {
-        &mut []
-      }
-    } else {
-      return #core::_ops::throw_type_error(scope, format!("Expected Float64Array at position {}", #idx));
-    }
-  }
-}
-
-fn codegen_sync_ret(
-  core: &TokenStream2,
-  output: &syn::ReturnType,
-) -> TokenStream2 {
-  if is_void(output) {
-    return quote! {};
-  }
-
-  if is_u32_rv(output) {
-    return quote! {
-      rv.set_uint32(result as u32);
-    };
-  }
-
-  // Optimize Result<(), Err> to skip serde_v8 when Ok(...)
-  let ok_block = if is_unit_result(output) {
-    quote! {}
-  } else if is_u32_rv_result(output) {
-    quote! {
-      rv.set_uint32(result as u32);
-    }
-  } else if is_ptr_cvoid(output) || is_ptr_cvoid_rv(output) {
-    quote! {
-      if result.is_null() {
-        // External cannot contain a null pointer, null pointers are instead represented as null.
-        rv.set_null();
-      } else {
-        rv.set(v8::External::new(scope, result as *mut ::std::ffi::c_void).into());
-      }
-    }
-  } else {
-    quote! {
-      match #core::serde_v8::to_v8(scope, result) {
-        Ok(ret) => rv.set(ret),
-        Err(err) => #core::_ops::throw_type_error(
-          scope,
-          format!("Error serializing return: {}", #core::anyhow::Error::from(err)),
-        ),
-      };
-    }
-  };
-
-  if !is_result(output) {
-    return ok_block;
-  }
-
-  quote! {
-    match result {
-      Ok(result) => {
-        #ok_block
-      },
-      Err(err) => {
-        let exception = #core::error::to_v8_error(scope, ctx.get_error_class_fn, &err);
-        scope.throw_exception(exception);
-      },
-    };
-  }
-}
-
-fn is_void(ty: impl ToTokens) -> bool {
-  tokens(ty).is_empty()
-}
-
-fn is_result(ty: impl ToTokens) -> bool {
-  let tokens = tokens(ty);
-  if tokens.trim_start_matches("-> ").starts_with("Result <") {
-    return true;
-  }
-  // Detect `io::Result<...>`, `anyhow::Result<...>`, etc...
-  // i.e: Result aliases/shorthands which are unfortunately "opaque" at macro-time
-  match tokens.find(":: Result <") {
-    Some(idx) => !tokens.split_at(idx).0.contains('<'),
-    None => false,
-  }
-}
-
-fn is_string(ty: impl ToTokens) -> Option<bool> {
-  let toks = tokens(ty);
-  if toks == "String" {
-    return Some(false);
-  }
-  if toks == "& str" {
-    return Some(true);
-  }
-  None
-}
-
-fn is_option_string(ty: impl ToTokens) -> bool {
-  tokens(ty) == "Option < String >"
-}
-
-fn is_cow_str(ty: impl ToTokens) -> bool {
-  tokens(&ty).starts_with("Cow <") && tokens(&ty).ends_with("str >")
-}
-
-enum SliceType {
-  U8,
-  U8Mut,
-  U32Mut,
-  F64Mut,
-}
-
-fn is_ref_slice(ty: impl ToTokens) -> Option<SliceType> {
-  if is_u8_slice(&ty) {
-    return Some(SliceType::U8);
-  }
-  if is_u8_slice_mut(&ty) {
-    return Some(SliceType::U8Mut);
-  }
-  if is_u32_slice_mut(&ty) {
-    return Some(SliceType::U32Mut);
-  }
-  if is_f64_slice_mut(&ty) {
-    return Some(SliceType::F64Mut);
-  }
-  None
-}
-
-fn is_u8_slice(ty: impl ToTokens) -> bool {
-  tokens(ty) == "& [u8]"
-}
-
-fn is_u8_slice_mut(ty: impl ToTokens) -> bool {
-  tokens(ty) == "& mut [u8]"
-}
-
-fn is_u32_slice_mut(ty: impl ToTokens) -> bool {
-  tokens(ty) == "& mut [u32]"
-}
-
-fn is_f64_slice_mut(ty: impl ToTokens) -> bool {
-  tokens(ty) == "& mut [f64]"
-}
-
-fn is_ptr_u8(ty: impl ToTokens) -> bool {
-  tokens(ty) == "* const u8"
-}
-
-fn is_ptr_cvoid(ty: impl ToTokens) -> bool {
-  tokens(&ty) == "* const c_void" || tokens(&ty) == "* mut c_void"
-}
-
-fn is_ptr_cvoid_rv(ty: impl ToTokens) -> bool {
-  tokens(&ty).contains("Result < * const c_void")
-    || tokens(&ty).contains("Result < * mut c_void")
-}
-
-fn is_optional_fast_callback_option(ty: impl ToTokens) -> bool {
-  tokens(&ty).contains("Option < & mut FastApiCallbackOptions")
-}
-
-fn is_optional_wasm_memory(ty: impl ToTokens) -> bool {
-  tokens(&ty).contains("Option < & mut [u8]")
-}
-
-/// Detects if the type can be set using `rv.set_uint32` fast path
-fn is_u32_rv(ty: impl ToTokens) -> bool {
-  ["u32", "u8", "u16"].iter().any(|&s| tokens(&ty) == s) || is_resource_id(&ty)
-}
-
-/// Detects if the type is of the format Result<u32/u8/u16, Err>
-fn is_u32_rv_result(ty: impl ToTokens) -> bool {
-  is_result(&ty)
-    && (tokens(&ty).contains("Result < u32")
-      || tokens(&ty).contains("Result < u8")
-      || tokens(&ty).contains("Result < u16")
-      || is_resource_id(&ty))
-}
-
-/// Detects if a type is of the form Result<(), Err>
-fn is_unit_result(ty: impl ToTokens) -> bool {
-  is_result(&ty) && tokens(&ty).contains("Result < ()")
-}
-
-fn is_resource_id(arg: impl ToTokens) -> bool {
-  let re = lazy_regex::regex!(r#": (?:deno_core :: )?ResourceId$"#);
-  re.is_match(&tokens(arg))
-}
-
-fn is_mut_ref_opstate(arg: impl ToTokens) -> bool {
-  let re = lazy_regex::regex!(r#": & mut (?:deno_core :: )?OpState$"#);
-  re.is_match(&tokens(arg))
-}
-
-fn is_rc_refcell_opstate(arg: &syn::FnArg) -> bool {
-  let re =
-    lazy_regex::regex!(r#": Rc < RefCell < (?:deno_core :: )?OpState > >$"#);
-  re.is_match(&tokens(arg))
-}
-
-fn is_handle_scope(arg: &syn::FnArg) -> bool {
-  let re = lazy_regex::regex!(
-    r#": & mut (?:deno_core :: )?v8 :: HandleScope(?: < '\w+ >)?$"#
-  );
-  re.is_match(&tokens(arg))
-}
-
-fn is_future(ty: impl ToTokens) -> bool {
-  tokens(&ty).contains("impl Future < Output =")
-}
-
-fn tokens(x: impl ToTokens) -> String {
-  x.to_token_stream().to_string()
-}
-
-fn exclude_lifetime_params(
-  generic_params: &Punctuated<GenericParam, Comma>,
-) -> Punctuated<GenericParam, Comma> {
-  generic_params
-    .iter()
-    .filter(|t| !tokens(t).starts_with('\''))
-    .cloned()
-    .collect::<Punctuated<GenericParam, Comma>>()
-}
-
-fn exclude_non_lifetime_params(
-  generic_params: &Punctuated<GenericParam, Comma>,
-) -> Punctuated<GenericParam, Comma> {
-  generic_params
-    .iter()
-    .filter(|t| tokens(t).starts_with('\''))
-    .cloned()
-    .collect::<Punctuated<GenericParam, Comma>>()
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::Attributes;
-  use crate::Op;
-  use pretty_assertions::assert_eq;
-  use std::path::PathBuf;
-
-  #[testing_macros::fixture("optimizer_tests/**/*.rs")]
-  fn test_codegen(input: PathBuf) {
-    let update_expected = std::env::var("UPDATE_EXPECTED").is_ok();
-
-    let source =
-      std::fs::read_to_string(&input).expect("Failed to read test file");
-
-    let mut attrs = Attributes::default();
-    if source.contains("// @test-attr:fast") {
-      attrs.must_be_fast = true;
-    }
-    if source.contains("// @test-attr:wasm") {
-      attrs.is_wasm = true;
-      attrs.must_be_fast = true;
-    }
-
-    let item = syn::parse_str(&source).expect("Failed to parse test file");
-    let op = Op::new(item, attrs);
-
-    let expected = std::fs::read_to_string(input.with_extension("out"))
-      .expect("Failed to read expected output file");
-
-    // Print the raw tokens in case we fail to parse
-    let actual = op.gen();
-    println!("-----Raw tokens-----\n{}----------\n", actual);
-
-    // Validate syntax tree.
-    let tree = syn::parse2(actual).unwrap();
-    let actual = prettyplease::unparse(&tree);
-    if update_expected {
-      std::fs::write(input.with_extension("out"), actual)
-        .expect("Failed to write expected file");
-    } else {
-      assert_eq!(actual, expected);
-    }
-  }
-}
diff --git a/ops/op1.md b/ops/op1.md
deleted file mode 100644
index a24797e..0000000
--- a/ops/op1.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# deno_ops
-
-`proc_macro` for generating highly optimized V8 functions from Deno ops.
-
-```rust,ignore
-// Declare an op.
-#[op(fast)]
-pub fn op_add(_: &mut OpState, a: i32, b: i32) -> i32 {
-  a + b
-}
-
-// Register with an extension.
-Extension {
-  name: "math",
-  ops: Cow::Borrowed(&[op_add::DECL]),
-  ..Default::default()
-}
-```
-
-## Performance
-
-The macro can optimize away code, short circuit fast paths and generate a Fast
-API impl.
-
-Cases where code is optimized away:
-
-- `-> ()` skips serde_v8 and `rv.set` calls.
-- `-> Result<(), E>` skips serde_v8 and `rv.set` calls for `Ok()` branch.
-- `-> ResourceId` or `-> [int]` types will use specialized method like
-  `v8::ReturnValue::set_uint32`. A fast path for SMI.
-- `-> Result<ResourceId, E>` or `-> Result<[int], E>` types will be optimized
-  like above for the `Ok()` branch.
-
-### Fast calls
-
-The macro will infer and try to auto generate V8 fast API call trait impl for
-`sync` ops with:
-
-- arguments: integers, bool, `&mut OpState`, `&[u8]`, `&mut [u8]`, `&[u32]`,
-  `&mut [u32]`
-- return_type: integers, bool
-
-The `#[op(fast)]` attribute should be used to enforce fast call generation at
-compile time.
-
-Trait gen for `async` ops & a ZeroCopyBuf equivalent type is planned and will be
-added soon.
-
-### Wasm calls
-
-The `#[op(wasm)]` attribute should be used for calls expected to be called from
-Wasm. This enables the fast call generation and allows seamless `WasmMemory`
-integration for generic and fast calls.
-
-```rust,ignore
-#[op(wasm)]
-pub fn op_args_get(
-  offset: i32,
-  buffer_offset: i32,
-  memory: Option<&[u8]>, // Must be last parameter. Some(..) when entered from Wasm.
-) {
-  // ...
-}
-```
diff --git a/ops/optimizer.rs b/ops/optimizer.rs
deleted file mode 100644
index d377128..0000000
--- a/ops/optimizer.rs
+++ /dev/null
@@ -1,976 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-//! Optimizer for #[op]
-
-use std::collections::BTreeMap;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-
-use pmutil::q;
-use pmutil::Quote;
-use proc_macro2::TokenStream;
-
-use syn::parse_quote;
-use syn::punctuated::Punctuated;
-use syn::token::PathSep;
-use syn::AngleBracketedGenericArguments;
-use syn::FnArg;
-use syn::GenericArgument;
-use syn::PatType;
-use syn::Path;
-use syn::PathArguments;
-use syn::PathSegment;
-use syn::ReturnType;
-use syn::Signature;
-use syn::Type;
-use syn::TypePath;
-use syn::TypePtr;
-use syn::TypeReference;
-use syn::TypeSlice;
-use syn::TypeTuple;
-
-use crate::Op;
-
-#[derive(Debug)]
-pub(crate) enum BailoutReason {
-  // Recoverable errors
-  MustBeSingleSegment,
-  FastUnsupportedParamType,
-}
-
-#[derive(Debug, PartialEq)]
-enum StringType {
-  Cow,
-  Ref,
-  Owned,
-}
-
-#[derive(Debug, PartialEq)]
-enum TransformKind {
-  // serde_v8::Value
-  V8Value,
-  SliceU32(bool),
-  SliceU8(bool),
-  SliceF64(bool),
-  SeqOneByteString(StringType),
-  PtrU8,
-  PtrVoid,
-  WasmMemory,
-}
-
-impl Transform {
-  fn serde_v8_value(index: usize) -> Self {
-    Transform {
-      kind: TransformKind::V8Value,
-      index,
-    }
-  }
-
-  fn slice_u32(index: usize, is_mut: bool) -> Self {
-    Transform {
-      kind: TransformKind::SliceU32(is_mut),
-      index,
-    }
-  }
-
-  fn slice_u8(index: usize, is_mut: bool) -> Self {
-    Transform {
-      kind: TransformKind::SliceU8(is_mut),
-      index,
-    }
-  }
-
-  fn slice_f64(index: usize, is_mut: bool) -> Self {
-    Transform {
-      kind: TransformKind::SliceF64(is_mut),
-      index,
-    }
-  }
-
-  fn seq_one_byte_string(index: usize, is_ref: StringType) -> Self {
-    Transform {
-      kind: TransformKind::SeqOneByteString(is_ref),
-      index,
-    }
-  }
-
-  fn wasm_memory(index: usize) -> Self {
-    Transform {
-      kind: TransformKind::WasmMemory,
-      index,
-    }
-  }
-
-  fn u8_ptr(index: usize) -> Self {
-    Transform {
-      kind: TransformKind::PtrU8,
-      index,
-    }
-  }
-
-  fn void_ptr(index: usize) -> Self {
-    Transform {
-      kind: TransformKind::PtrVoid,
-      index,
-    }
-  }
-}
-
-#[derive(Debug, PartialEq)]
-pub(crate) struct Transform {
-  kind: TransformKind,
-  index: usize,
-}
-
-impl Transform {
-  pub(crate) fn apply_for_fast_call(
-    &self,
-    core: &TokenStream,
-    input: &mut FnArg,
-  ) -> Quote {
-    let (ty, ident) = match input {
-      FnArg::Typed(PatType {
-        ref mut ty,
-        ref pat,
-        ..
-      }) => {
-        let ident = match &**pat {
-          syn::Pat::Ident(ident) => &ident.ident,
-          _ => unreachable!("error not recovered"),
-        };
-        (ty, ident)
-      }
-      _ => unreachable!("error not recovered"),
-    };
-
-    match &self.kind {
-      // serde_v8::Value
-      TransformKind::V8Value => {
-        *ty = parse_quote! { #core::v8::Local<#core::v8::Value> };
-
-        q!(Vars { var: &ident }, {
-          let var = serde_v8::Value { v8_value: var };
-        })
-      }
-      // &[u32]
-      TransformKind::SliceU32(_) => {
-        *ty =
-          parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u32> };
-
-        q!(Vars { var: &ident }, {
-          // V8 guarantees that ArrayBuffers are always 4-byte aligned
-          // (seems to be always 8-byte aligned on 64-bit machines)
-          // but Deno FFI makes it possible to create ArrayBuffers at any
-          // alignment. Thus this check is needed.
-          let var = match unsafe { &*var }.get_storage_if_aligned() {
-            Some(v) => v,
-            None => {
-              unsafe { &mut *fast_api_callback_options }.fallback = true;
-              return Default::default();
-            }
-          };
-        })
-      }
-      // &[u8]
-      TransformKind::SliceU8(_) => {
-        *ty =
-          parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u8> };
-
-        q!(Vars { var: &ident }, {
-          // SAFETY: U8 slice is always byte-aligned.
-          let var =
-            unsafe { (&*var).get_storage_if_aligned().unwrap_unchecked() };
-        })
-      }
-      TransformKind::SliceF64(_) => {
-        *ty =
-          parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<f64> };
-
-        q!(Vars { var: &ident }, {
-          let var = match unsafe { &*var }.get_storage_if_aligned() {
-            Some(v) => v,
-            None => {
-              unsafe { &mut *fast_api_callback_options }.fallback = true;
-              return Default::default();
-            }
-          };
-        })
-      }
-      // &str
-      TransformKind::SeqOneByteString(str_ty) => {
-        *ty = parse_quote! { *const #core::v8::fast_api::FastApiOneByteString };
-        match str_ty {
-          StringType::Ref => q!(Vars { var: &ident }, {
-            let var = match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
-              Ok(v) => v,
-              Err(_) => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-              }
-            };
-          }),
-          StringType::Cow => q!(Vars { var: &ident }, {
-            let var = ::std::borrow::Cow::Borrowed(
-              match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
-                Ok(v) => v,
-                Err(_) => {
-                  unsafe { &mut *fast_api_callback_options }.fallback = true;
-                  return Default::default();
-                }
-              },
-            );
-          }),
-          StringType::Owned => q!(Vars { var: &ident }, {
-            let var = match ::std::str::from_utf8(unsafe { &*var }.as_bytes()) {
-              Ok(v) => v.to_owned(),
-              Err(_) => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-              }
-            };
-          }),
-        }
-      }
-      TransformKind::WasmMemory => {
-        // Note: `ty` is correctly set to __opts by the fast call tier.
-        // U8 slice is always byte-aligned.
-        q!(Vars { var: &ident, core }, {
-          let var = unsafe {
-            &*(__opts.wasm_memory
-              as *const core::v8::fast_api::FastApiTypedArray<u8>)
-          }
-          .get_storage_if_aligned();
-        })
-      }
-      // *const u8
-      TransformKind::PtrU8 => {
-        *ty =
-          parse_quote! { *const #core::v8::fast_api::FastApiTypedArray<u8> };
-
-        q!(Vars { var: &ident }, {
-          // SAFETY: U8 slice is always byte-aligned.
-          let var =
-            unsafe { (&*var).get_storage_if_aligned().unwrap_unchecked() }
-              .as_ptr();
-        })
-      }
-      TransformKind::PtrVoid => {
-        *ty = parse_quote! { *mut ::std::ffi::c_void };
-
-        q!(Vars {}, {})
-      }
-    }
-  }
-}
-
-fn get_fast_scalar(s: &str) -> Option<FastValue> {
-  match s {
-    "bool" => Some(FastValue::Bool),
-    "u32" => Some(FastValue::U32),
-    "i32" => Some(FastValue::I32),
-    "u64" | "usize" => Some(FastValue::U64),
-    "i64" | "isize" => Some(FastValue::I64),
-    "f32" => Some(FastValue::F32),
-    "f64" => Some(FastValue::F64),
-    "* const c_void" | "* mut c_void" => Some(FastValue::Pointer),
-    "ResourceId" => Some(FastValue::U32),
-    _ => None,
-  }
-}
-
-fn can_return_fast(v: &FastValue) -> bool {
-  !matches!(
-    v,
-    FastValue::U64
-      | FastValue::I64
-      | FastValue::Uint8Array
-      | FastValue::Uint32Array
-  )
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub(crate) enum FastValue {
-  Void,
-  Bool,
-  U32,
-  I32,
-  U64,
-  I64,
-  F32,
-  F64,
-  Pointer,
-  V8Value,
-  Uint8Array,
-  Uint32Array,
-  Float64Array,
-  SeqOneByteString,
-}
-
-impl FastValue {
-  pub fn default_value(&self) -> Quote {
-    match self {
-      FastValue::Pointer => q!({ ::std::ptr::null_mut() }),
-      FastValue::Void => q!({}),
-      _ => q!({ Default::default() }),
-    }
-  }
-}
-
-impl Default for FastValue {
-  fn default() -> Self {
-    Self::Void
-  }
-}
-
-#[derive(Default, PartialEq)]
-pub(crate) struct Optimizer {
-  pub(crate) returns_result: bool,
-
-  pub(crate) has_ref_opstate: bool,
-
-  pub(crate) has_rc_opstate: bool,
-
-  // Do we need an explicit FastApiCallbackOptions argument?
-  pub(crate) has_fast_callback_option: bool,
-  // Do we depend on FastApiCallbackOptions?
-  pub(crate) needs_fast_callback_option: bool,
-
-  pub(crate) has_wasm_memory: bool,
-
-  pub(crate) fast_result: Option<FastValue>,
-  pub(crate) fast_parameters: Vec<FastValue>,
-
-  pub(crate) transforms: BTreeMap<usize, Transform>,
-  pub(crate) fast_compatible: bool,
-}
-
-impl Debug for Optimizer {
-  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-    writeln!(f, "=== Optimizer Dump ===")?;
-    writeln!(f, "returns_result: {}", self.returns_result)?;
-    writeln!(f, "has_ref_opstate: {}", self.has_ref_opstate)?;
-    writeln!(f, "has_rc_opstate: {}", self.has_rc_opstate)?;
-    writeln!(
-      f,
-      "has_fast_callback_option: {}",
-      self.has_fast_callback_option
-    )?;
-    writeln!(
-      f,
-      "needs_fast_callback_option: {}",
-      self.needs_fast_callback_option
-    )?;
-    writeln!(f, "fast_result: {:?}", self.fast_result)?;
-    writeln!(f, "fast_parameters: {:?}", self.fast_parameters)?;
-    writeln!(f, "transforms: {:?}", self.transforms)?;
-    writeln!(f, "is_async: false")?;
-    writeln!(f, "fast_compatible: {}", self.fast_compatible)?;
-    Ok(())
-  }
-}
-
-impl Optimizer {
-  pub(crate) fn new() -> Self {
-    Default::default()
-  }
-
-  pub(crate) const fn has_opstate_in_parameters(&self) -> bool {
-    self.has_ref_opstate || self.has_rc_opstate
-  }
-
-  pub(crate) const fn needs_opstate(&self) -> bool {
-    self.has_ref_opstate || self.has_rc_opstate || self.returns_result
-  }
-
-  pub(crate) fn analyze(&mut self, op: &mut Op) -> Result<(), BailoutReason> {
-    if op.attrs.is_v8 {
-      self.fast_compatible = false;
-      return Ok(());
-    }
-
-    self.fast_compatible = true;
-    // Just assume for now. We will validate later.
-    self.has_wasm_memory = op.attrs.is_wasm;
-
-    let sig = &op.item.sig;
-
-    // Analyze return type
-    match &sig {
-      Signature {
-        output: ReturnType::Default,
-        ..
-      } => self.fast_result = Some(FastValue::default()),
-      Signature {
-        output: ReturnType::Type(_, ty),
-        ..
-      } => self.analyze_return_type(ty)?,
-    };
-
-    // The receiver, which we don't actually care about.
-    self.fast_parameters.push(FastValue::V8Value);
-
-    // Analyze parameters
-    for (index, param) in sig.inputs.iter().enumerate() {
-      self.analyze_param_type(index, param)?;
-    }
-
-    // TODO(@littledivy): https://github.com/denoland/deno/issues/17159
-    if self.returns_result
-      && self.fast_parameters.contains(&FastValue::SeqOneByteString)
-    {
-      self.fast_compatible = false;
-    }
-
-    Ok(())
-  }
-
-  fn analyze_return_type(&mut self, ty: &Type) -> Result<(), BailoutReason> {
-    match ty {
-      Type::Tuple(TypeTuple { elems, .. }) if elems.is_empty() => {
-        self.fast_result = Some(FastValue::Void);
-      }
-      Type::Path(TypePath {
-        path: Path { segments, .. },
-        ..
-      }) => {
-        let segment = single_segment(segments)?;
-
-        match segment {
-          // Result<T, E>
-          PathSegment {
-            ident, arguments, ..
-          } if ident == "Result" => {
-            self.returns_result = true;
-
-            if let PathArguments::AngleBracketed(
-              AngleBracketedGenericArguments { args, .. },
-            ) = arguments
-            {
-              match args.first() {
-                Some(GenericArgument::Type(Type::Path(TypePath {
-                  path: Path { segments, .. },
-                  ..
-                }))) => {
-                  let PathSegment { ident, .. } = single_segment(segments)?;
-                  // Is `T` a scalar FastValue?
-                  if let Some(val) = get_fast_scalar(ident.to_string().as_str())
-                  {
-                    if can_return_fast(&val) {
-                      self.fast_result = Some(val);
-                      return Ok(());
-                    }
-                  }
-
-                  self.fast_compatible = false;
-                  return Err(BailoutReason::FastUnsupportedParamType);
-                }
-                Some(GenericArgument::Type(Type::Tuple(TypeTuple {
-                  elems,
-                  ..
-                })))
-                  if elems.is_empty() =>
-                {
-                  self.fast_result = Some(FastValue::Void);
-                }
-                Some(GenericArgument::Type(Type::Ptr(TypePtr {
-                  mutability: Some(_),
-                  elem,
-                  ..
-                }))) => {
-                  match &**elem {
-                    Type::Path(TypePath {
-                      path: Path { segments, .. },
-                      ..
-                    }) => {
-                      // Is `T` a c_void?
-                      let segment = single_segment(segments)?;
-                      match segment {
-                        PathSegment { ident, .. } if ident == "c_void" => {
-                          self.fast_result = Some(FastValue::Pointer);
-                          return Ok(());
-                        }
-                        _ => {
-                          return Err(BailoutReason::FastUnsupportedParamType)
-                        }
-                      }
-                    }
-                    _ => return Err(BailoutReason::FastUnsupportedParamType),
-                  }
-                }
-                _ => return Err(BailoutReason::FastUnsupportedParamType),
-              }
-            }
-          }
-          // Is `T` a scalar FastValue?
-          PathSegment { ident, .. } => {
-            if let Some(val) = get_fast_scalar(ident.to_string().as_str()) {
-              self.fast_result = Some(val);
-              return Ok(());
-            }
-
-            self.fast_compatible = false;
-            return Err(BailoutReason::FastUnsupportedParamType);
-          }
-        };
-      }
-      Type::Ptr(TypePtr {
-        mutability: Some(_),
-        elem,
-        ..
-      }) => {
-        match &**elem {
-          Type::Path(TypePath {
-            path: Path { segments, .. },
-            ..
-          }) => {
-            // Is `T` a c_void?
-            let segment = single_segment(segments)?;
-            match segment {
-              PathSegment { ident, .. } if ident == "c_void" => {
-                self.fast_result = Some(FastValue::Pointer);
-                return Ok(());
-              }
-              _ => return Err(BailoutReason::FastUnsupportedParamType),
-            }
-          }
-          _ => return Err(BailoutReason::FastUnsupportedParamType),
-        }
-      }
-      _ => return Err(BailoutReason::FastUnsupportedParamType),
-    };
-
-    Ok(())
-  }
-
-  fn analyze_param_type(
-    &mut self,
-    index: usize,
-    arg: &FnArg,
-  ) -> Result<(), BailoutReason> {
-    match arg {
-      FnArg::Typed(typed) => match &*typed.ty {
-        Type::Path(TypePath {
-          path: Path { segments, .. },
-          ..
-        }) if segments.len() == 2 => {
-          match double_segment(segments)? {
-            // -> serde_v8::Value
-            [PathSegment { ident: first, .. }, PathSegment { ident: last, .. }]
-              if first == "serde_v8" && last == "Value" =>
-            {
-              self.fast_parameters.push(FastValue::V8Value);
-              assert!(self
-                .transforms
-                .insert(index, Transform::serde_v8_value(index))
-                .is_none());
-            }
-            _ => return Err(BailoutReason::FastUnsupportedParamType),
-          }
-        }
-        Type::Path(TypePath {
-          path: Path { segments, .. },
-          ..
-        }) => {
-          let segment = single_segment(segments)?;
-
-          match segment {
-            // -> Option<T>
-            PathSegment {
-              ident, arguments, ..
-            } if ident == "Option" => {
-              if let PathArguments::AngleBracketed(
-                AngleBracketedGenericArguments { args, .. },
-              ) = arguments
-              {
-                // -> Option<&mut T>
-                if let Some(GenericArgument::Type(Type::Reference(
-                  TypeReference { elem, .. },
-                ))) = args.last()
-                {
-                  if self.has_wasm_memory {
-                    // -> Option<&mut [u8]>
-                    if let Type::Slice(TypeSlice { elem, .. }) = &**elem {
-                      if let Type::Path(TypePath {
-                        path: Path { segments, .. },
-                        ..
-                      }) = &**elem
-                      {
-                        let segment = single_segment(segments)?;
-
-                        match segment {
-                          // Is `T` a u8?
-                          PathSegment { ident, .. } if ident == "u8" => {
-                            assert!(self
-                              .transforms
-                              .insert(index, Transform::wasm_memory(index))
-                              .is_none());
-                          }
-                          _ => {
-                            return Err(BailoutReason::FastUnsupportedParamType)
-                          }
-                        }
-                      }
-                    }
-                  } else if let Type::Path(TypePath {
-                    path: Path { segments, .. },
-                    ..
-                  }) = &**elem
-                  {
-                    let segment = single_segment(segments)?;
-                    match segment {
-                      // Is `T` a FastApiCallbackOptions?
-                      PathSegment { ident, .. }
-                        if ident == "FastApiCallbackOptions" =>
-                      {
-                        self.has_fast_callback_option = true;
-                      }
-                      _ => return Err(BailoutReason::FastUnsupportedParamType),
-                    }
-                  } else {
-                    return Err(BailoutReason::FastUnsupportedParamType);
-                  }
-                } else {
-                  return Err(BailoutReason::FastUnsupportedParamType);
-                }
-              }
-            }
-            // -> Rc<T>
-            PathSegment {
-              ident, arguments, ..
-            } if ident == "Rc" => {
-              if let PathArguments::AngleBracketed(
-                AngleBracketedGenericArguments { args, .. },
-              ) = arguments
-              {
-                match args.last() {
-                  Some(GenericArgument::Type(Type::Path(TypePath {
-                    path: Path { segments, .. },
-                    ..
-                  }))) => {
-                    let segment = single_segment(segments)?;
-                    match segment {
-                      // -> Rc<RefCell<T>>
-                      PathSegment {
-                        ident, arguments, ..
-                      } if ident == "RefCell" => {
-                        if let PathArguments::AngleBracketed(
-                          AngleBracketedGenericArguments { args, .. },
-                        ) = arguments
-                        {
-                          match args.last() {
-                            // -> Rc<RefCell<OpState>>
-                            Some(GenericArgument::Type(Type::Path(
-                              TypePath {
-                                path: Path { segments, .. },
-                                ..
-                              },
-                            ))) => {
-                              let segment = single_segment(segments)?;
-                              match segment {
-                                PathSegment { ident, .. }
-                                  if ident == "OpState" =>
-                                {
-                                  self.has_rc_opstate = true;
-                                }
-                                _ => {
-                                  return Err(
-                                    BailoutReason::FastUnsupportedParamType,
-                                  )
-                                }
-                              }
-                            }
-                            _ => {
-                              return Err(
-                                BailoutReason::FastUnsupportedParamType,
-                              )
-                            }
-                          }
-                        }
-                      }
-                      _ => return Err(BailoutReason::FastUnsupportedParamType),
-                    }
-                  }
-                  _ => return Err(BailoutReason::FastUnsupportedParamType),
-                }
-              }
-            }
-            // Cow<'_, str>
-            PathSegment {
-              ident, arguments, ..
-            } if ident == "Cow" => {
-              if let PathArguments::AngleBracketed(
-                AngleBracketedGenericArguments { args, .. },
-              ) = arguments
-              {
-                assert_eq!(args.len(), 2);
-
-                let ty = &args[1];
-                match ty {
-                  GenericArgument::Type(Type::Path(TypePath {
-                    path: Path { segments, .. },
-                    ..
-                  })) => {
-                    let segment = single_segment(segments)?;
-                    match segment {
-                      PathSegment { ident, .. } if ident == "str" => {
-                        self.needs_fast_callback_option = true;
-                        self.fast_parameters.push(FastValue::SeqOneByteString);
-                        assert!(self
-                          .transforms
-                          .insert(
-                            index,
-                            Transform::seq_one_byte_string(
-                              index,
-                              StringType::Cow
-                            )
-                          )
-                          .is_none());
-                      }
-                      _ => return Err(BailoutReason::FastUnsupportedParamType),
-                    }
-                  }
-                  _ => return Err(BailoutReason::FastUnsupportedParamType),
-                }
-              }
-            }
-            // Is `T` a fast scalar?
-            PathSegment { ident, .. } => {
-              if let Some(val) = get_fast_scalar(ident.to_string().as_str()) {
-                self.fast_parameters.push(val);
-              } else if ident == "String" {
-                self.needs_fast_callback_option = true;
-                // Is `T` an owned String?
-                self.fast_parameters.push(FastValue::SeqOneByteString);
-                assert!(self
-                  .transforms
-                  .insert(
-                    index,
-                    Transform::seq_one_byte_string(index, StringType::Owned)
-                  )
-                  .is_none());
-              } else {
-                return Err(BailoutReason::FastUnsupportedParamType);
-              }
-            }
-          };
-        }
-        // &mut T
-        Type::Reference(TypeReference {
-          elem, mutability, ..
-        }) => match &**elem {
-          Type::Path(TypePath {
-            path: Path { segments, .. },
-            ..
-          }) => {
-            let segment = single_segment(segments)?;
-            match segment {
-              // Is `T` a OpState?
-              PathSegment { ident, .. } if ident == "OpState" => {
-                self.has_ref_opstate = true;
-              }
-              // Is `T` a str?
-              PathSegment { ident, .. } if ident == "str" => {
-                self.needs_fast_callback_option = true;
-                self.fast_parameters.push(FastValue::SeqOneByteString);
-                assert!(self
-                  .transforms
-                  .insert(
-                    index,
-                    Transform::seq_one_byte_string(index, StringType::Ref)
-                  )
-                  .is_none());
-              }
-              _ => return Err(BailoutReason::FastUnsupportedParamType),
-            }
-          }
-          // &mut [T]
-          Type::Slice(TypeSlice { elem, .. }) => match &**elem {
-            Type::Path(TypePath {
-              path: Path { segments, .. },
-              ..
-            }) => {
-              let segment = single_segment(segments)?;
-              let is_mut_ref = mutability.is_some();
-              match segment {
-                // Is `T` a u8?
-                PathSegment { ident, .. } if ident == "u8" => {
-                  self.fast_parameters.push(FastValue::Uint8Array);
-                  assert!(self
-                    .transforms
-                    .insert(index, Transform::slice_u8(index, is_mut_ref))
-                    .is_none());
-                }
-                // Is `T` a u32?
-                PathSegment { ident, .. } if ident == "u32" => {
-                  self.needs_fast_callback_option = true;
-                  self.fast_parameters.push(FastValue::Uint32Array);
-                  assert!(self
-                    .transforms
-                    .insert(index, Transform::slice_u32(index, is_mut_ref))
-                    .is_none());
-                }
-                // Is `T` a f64?
-                PathSegment { ident, .. } if ident == "f64" => {
-                  self.needs_fast_callback_option = true;
-                  self.fast_parameters.push(FastValue::Float64Array);
-                  assert!(self
-                    .transforms
-                    .insert(index, Transform::slice_f64(index, is_mut_ref))
-                    .is_none());
-                }
-                _ => return Err(BailoutReason::FastUnsupportedParamType),
-              }
-            }
-            _ => return Err(BailoutReason::FastUnsupportedParamType),
-          },
-          _ => return Err(BailoutReason::FastUnsupportedParamType),
-        },
-        // *const T
-        Type::Ptr(TypePtr {
-          elem,
-          const_token: Some(_),
-          ..
-        }) => match &**elem {
-          Type::Path(TypePath {
-            path: Path { segments, .. },
-            ..
-          }) => {
-            let segment = single_segment(segments)?;
-            match segment {
-              // Is `T` a u8?
-              PathSegment { ident, .. } if ident == "u8" => {
-                self.fast_parameters.push(FastValue::Uint8Array);
-                assert!(self
-                  .transforms
-                  .insert(index, Transform::u8_ptr(index))
-                  .is_none());
-              }
-              _ => return Err(BailoutReason::FastUnsupportedParamType),
-            }
-          }
-          _ => return Err(BailoutReason::FastUnsupportedParamType),
-        },
-        // *const T
-        Type::Ptr(TypePtr {
-          elem,
-          mutability: Some(_),
-          ..
-        }) => match &**elem {
-          Type::Path(TypePath {
-            path: Path { segments, .. },
-            ..
-          }) => {
-            let segment = single_segment(segments)?;
-            match segment {
-              // Is `T` a c_void?
-              PathSegment { ident, .. } if ident == "c_void" => {
-                self.fast_parameters.push(FastValue::Pointer);
-                assert!(self
-                  .transforms
-                  .insert(index, Transform::void_ptr(index))
-                  .is_none());
-              }
-              _ => return Err(BailoutReason::FastUnsupportedParamType),
-            }
-          }
-          _ => return Err(BailoutReason::FastUnsupportedParamType),
-        },
-        _ => return Err(BailoutReason::FastUnsupportedParamType),
-      },
-      _ => return Err(BailoutReason::FastUnsupportedParamType),
-    };
-    Ok(())
-  }
-}
-
-fn single_segment(
-  segments: &Punctuated<PathSegment, PathSep>,
-) -> Result<&PathSegment, BailoutReason> {
-  if segments.len() != 1 {
-    return Err(BailoutReason::MustBeSingleSegment);
-  }
-
-  match segments.last() {
-    Some(segment) => Ok(segment),
-    None => Err(BailoutReason::MustBeSingleSegment),
-  }
-}
-
-fn double_segment(
-  segments: &Punctuated<PathSegment, PathSep>,
-) -> Result<[&PathSegment; 2], BailoutReason> {
-  match (segments.first(), segments.last()) {
-    (Some(first), Some(last)) => Ok([first, last]),
-    // Caller ensures that there are only two segments.
-    _ => unreachable!(),
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-  use crate::Attributes;
-  use crate::Op;
-  use pretty_assertions::assert_eq;
-  use std::path::PathBuf;
-  use syn::parse_quote;
-
-  #[test]
-  fn test_single_segment() {
-    let segments = parse_quote!(foo);
-    assert!(single_segment(&segments).is_ok());
-
-    let segments = parse_quote!(foo::bar);
-    assert!(single_segment(&segments).is_err());
-  }
-
-  #[test]
-  fn test_double_segment() {
-    let segments = parse_quote!(foo::bar);
-    assert!(double_segment(&segments).is_ok());
-    assert_eq!(double_segment(&segments).unwrap()[0].ident, "foo");
-    assert_eq!(double_segment(&segments).unwrap()[1].ident, "bar");
-  }
-
-  #[testing_macros::fixture("optimizer_tests/**/*.rs")]
-  fn test_analyzer(input: PathBuf) {
-    let update_expected = std::env::var("UPDATE_EXPECTED").is_ok();
-
-    let source =
-      std::fs::read_to_string(&input).expect("Failed to read test file");
-    let expected = std::fs::read_to_string(input.with_extension("expected"))
-      .expect("Failed to read expected file");
-
-    let mut attrs = Attributes::default();
-    if source.contains("// @test-attr:wasm") {
-      attrs.must_be_fast = true;
-      attrs.is_wasm = true;
-    }
-    if source.contains("// @test-attr:fast") {
-      attrs.must_be_fast = true;
-    }
-
-    let item = syn::parse_str(&source).expect("Failed to parse test file");
-    let mut op = Op::new(item, attrs);
-    let mut optimizer = Optimizer::new();
-    if let Err(e) = optimizer.analyze(&mut op) {
-      let e_str = format!("{e:?}");
-      if update_expected {
-        std::fs::write(input.with_extension("expected"), e_str)
-          .expect("Failed to write expected file");
-      } else {
-        assert_eq!(e_str, expected);
-      }
-      return;
-    }
-
-    if update_expected {
-      std::fs::write(
-        input.with_extension("expected"),
-        format!("{optimizer:#?}"),
-      )
-      .expect("Failed to write expected file");
-    } else {
-      assert_eq!(format!("{optimizer:#?}"), expected);
-    }
-  }
-}


Test patch:
diff --git a/ops/optimizer_tests/callback_options.expected b/ops/optimizer_tests/callback_options.expected
deleted file mode 100644
index 245fdfd..0000000
--- a/ops/optimizer_tests/callback_options.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: true
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/callback_options.out b/ops/optimizer_tests/callback_options.out
deleted file mode 100644
index c5896c3..0000000
--- a/ops/optimizer_tests/callback_options.out
+++ /dev/null
@@ -1,90 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_fallback::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_fallback {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_fallback {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_fallback);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, CallbackOptions],
-                    CType::Void,
-                    Self::op_fallback_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_fallback {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_fallback)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(options: Option<&mut FastApiCallbackOptions>) {
-        if let Some(options) = options {
-            options.fallback = true;
-        }
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = None;
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl op_fallback {
-    #[allow(clippy::too_many_arguments)]
-    fn op_fallback_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let result = Self::call(options);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/callback_options.rs b/ops/optimizer_tests/callback_options.rs
deleted file mode 100644
index c210171..0000000
--- a/ops/optimizer_tests/callback_options.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn op_fallback(options: Option<&mut FastApiCallbackOptions>) {
-  if let Some(options) = options {
-    options.fallback = true;
-  }
-}
diff --git a/ops/optimizer_tests/cow_str.expected b/ops/optimizer_tests/cow_str.expected
deleted file mode 100644
index 9db8cfa..0000000
--- a/ops/optimizer_tests/cow_str.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(Void)
-fast_parameters: [V8Value, SeqOneByteString]
-transforms: {0: Transform { kind: SeqOneByteString(Cow), index: 0 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/cow_str.out b/ops/optimizer_tests/cow_str.out
deleted file mode 100644
index 784fdd8..0000000
--- a/ops/optimizer_tests/cow_str.out
+++ /dev/null
@@ -1,105 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_cow_str::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_cow_str {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_cow_str {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_cow_str);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, SeqOneByteString, CallbackOptions],
-                    CType::Void,
-                    Self::op_cow_str_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_cow_str {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_cow_str)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(c: Cow<'_, str>) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = match deno_core::v8::Local::<
-            deno_core::v8::String,
-        >::try_from(args.get(0usize as i32)) {
-            Ok(v8_string) => {
-                ::std::borrow::Cow::Owned(deno_core::serde_v8::to_utf8(v8_string, scope))
-            }
-            Err(_) => {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected string at position {}", 0usize),
-                );
-            }
-        };
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl op_cow_str {
-    #[allow(clippy::too_many_arguments)]
-    fn op_cow_str_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        c: *const deno_core::v8::fast_api::FastApiOneByteString,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let c = ::std::borrow::Cow::Borrowed(
-            match ::std::str::from_utf8(unsafe { &*c }.as_bytes()) {
-                Ok(v) => v,
-                Err(_) => {
-                    unsafe { &mut *fast_api_callback_options }.fallback = true;
-                    return Default::default();
-                }
-            },
-        );
-        let result = Self::call(c);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/cow_str.rs b/ops/optimizer_tests/cow_str.rs
deleted file mode 100644
index b7214bd..0000000
--- a/ops/optimizer_tests/cow_str.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_cow_str(c: Cow<'_, str>) {
-  // ...
-}
diff --git a/ops/optimizer_tests/f64_slice.expected b/ops/optimizer_tests/f64_slice.expected
deleted file mode 100644
index 32182b0..0000000
--- a/ops/optimizer_tests/f64_slice.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(Void)
-fast_parameters: [V8Value, Float64Array]
-transforms: {0: Transform { kind: SliceF64(true), index: 0 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/f64_slice.out b/ops/optimizer_tests/f64_slice.out
deleted file mode 100644
index 186add2..0000000
--- a/ops/optimizer_tests/f64_slice.out
+++ /dev/null
@@ -1,120 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_f64_buf::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_f64_buf {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_f64_buf {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_f64_buf);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, TypedArray(CType::Float64), CallbackOptions],
-                    CType::Void,
-                    Self::op_f64_buf_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_f64_buf {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_f64_buf)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(buffer: &mut [f64]) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = if let Ok(view) = deno_core::v8::Local::<
-            deno_core::v8::Float64Array,
-        >::try_from(args.get(0usize as i32)) {
-            let (offset, len) = (view.byte_offset(), view.byte_length());
-            let buffer = match view.buffer(scope) {
-                Some(v) => v,
-                None => {
-                    return deno_core::_ops::throw_type_error(
-                        scope,
-                        format!("Expected Float64Array at position {}", 0usize),
-                    );
-                }
-            };
-            if let Some(data) = buffer.data() {
-                let store = data.cast::<u8>().as_ptr();
-                unsafe {
-                    ::std::slice::from_raw_parts_mut(
-                        store.add(offset) as *mut f64,
-                        len / 8,
-                    )
-                }
-            } else {
-                &mut []
-            }
-        } else {
-            return deno_core::_ops::throw_type_error(
-                scope,
-                format!("Expected Float64Array at position {}", 0usize),
-            );
-        };
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl op_f64_buf {
-    #[allow(clippy::too_many_arguments)]
-    fn op_f64_buf_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        buffer: *const deno_core::v8::fast_api::FastApiTypedArray<f64>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let buffer = match unsafe { &*buffer }.get_storage_if_aligned() {
-            Some(v) => v,
-            None => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-            }
-        };
-        let result = Self::call(buffer);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/f64_slice.rs b/ops/optimizer_tests/f64_slice.rs
deleted file mode 100644
index fa27785..0000000
--- a/ops/optimizer_tests/f64_slice.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_f64_buf(buffer: &mut [f64]) {
-  // @test-attr:fast
-}
diff --git a/ops/optimizer_tests/incompatible_1.expected b/ops/optimizer_tests/incompatible_1.expected
deleted file mode 100644
index 250ff10..0000000
--- a/ops/optimizer_tests/incompatible_1.expected
+++ /dev/null
@@ -1,1 +0,0 @@
-FastUnsupportedParamType
\ No newline at end of file
diff --git a/ops/optimizer_tests/incompatible_1.out b/ops/optimizer_tests/incompatible_1.out
deleted file mode 100644
index 583a874..0000000
--- a/ops/optimizer_tests/incompatible_1.out
+++ /dev/null
@@ -1,87 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_sync_serialize_object_with_numbers_as_keys::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_sync_serialize_object_with_numbers_as_keys {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_sync_serialize_object_with_numbers_as_keys {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_sync_serialize_object_with_numbers_as_keys);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_sync_serialize_object_with_numbers_as_keys {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_sync_serialize_object_with_numbers_as_keys)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(value: serde_json::Value) -> Result<(), Error> {
-        assert_eq!(
-            value.to_string(), r#"{"lines":{"100":{"unit":"m"},"200":{"unit":"cm"}}}"#
-        );
-        Ok(())
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {}
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/incompatible_1.rs b/ops/optimizer_tests/incompatible_1.rs
deleted file mode 100644
index 326189a..0000000
--- a/ops/optimizer_tests/incompatible_1.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-fn op_sync_serialize_object_with_numbers_as_keys(
-  value: serde_json::Value,
-) -> Result<(), Error> {
-  assert_eq!(
-    value.to_string(),
-    r#"{"lines":{"100":{"unit":"m"},"200":{"unit":"cm"}}}"#
-  );
-  Ok(())
-}
diff --git a/ops/optimizer_tests/op_blob_revoke_object_url.expected b/ops/optimizer_tests/op_blob_revoke_object_url.expected
deleted file mode 100644
index a412ece..0000000
--- a/ops/optimizer_tests/op_blob_revoke_object_url.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(Void)
-fast_parameters: [V8Value, SeqOneByteString]
-transforms: {1: Transform { kind: SeqOneByteString(Owned), index: 1 }}
-is_async: false
-fast_compatible: false
diff --git a/ops/optimizer_tests/op_blob_revoke_object_url.out b/ops/optimizer_tests/op_blob_revoke_object_url.out
deleted file mode 100644
index 7d845c6..0000000
--- a/ops/optimizer_tests/op_blob_revoke_object_url.out
+++ /dev/null
@@ -1,90 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_blob_revoke_object_url::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_blob_revoke_object_url {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_blob_revoke_object_url {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_blob_revoke_object_url);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_blob_revoke_object_url {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_blob_revoke_object_url)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(state: &mut OpState, url: String) -> Result<(), AnyError> {
-        let url = Url::parse(&url)?;
-        let blob_store = state.borrow::<BlobStore>();
-        blob_store.remove_object_url(&url);
-        Ok(())
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = match deno_core::v8::Local::<
-            deno_core::v8::String,
-        >::try_from(args.get(0usize as i32)) {
-            Ok(v8_string) => deno_core::serde_v8::to_utf8(v8_string, scope),
-            Err(_) => {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected string at position {}", 0usize),
-                );
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {}
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/op_blob_revoke_object_url.rs b/ops/optimizer_tests/op_blob_revoke_object_url.rs
deleted file mode 100644
index 4ef7938..0000000
--- a/ops/optimizer_tests/op_blob_revoke_object_url.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn op_blob_revoke_object_url(
-  state: &mut OpState,
-  url: String,
-) -> Result<(), AnyError> {
-  // TODO(@littledivy): fast compatible https://github.com/denoland/deno/issues/17159
-  let url = Url::parse(&url)?;
-  let blob_store = state.borrow::<BlobStore>();
-  blob_store.remove_object_url(&url);
-  Ok(())
-}
diff --git a/ops/optimizer_tests/op_ffi_ptr_value.expected b/ops/optimizer_tests/op_ffi_ptr_value.expected
deleted file mode 100644
index 00a2859..0000000
--- a/ops/optimizer_tests/op_ffi_ptr_value.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(Void)
-fast_parameters: [V8Value, Pointer, Uint32Array]
-transforms: {0: Transform { kind: PtrVoid, index: 0 }, 1: Transform { kind: SliceU32(true), index: 1 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_ffi_ptr_value.out b/ops/optimizer_tests/op_ffi_ptr_value.out
deleted file mode 100644
index b159051..0000000
--- a/ops/optimizer_tests/op_ffi_ptr_value.out
+++ /dev/null
@@ -1,136 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_ffi_ptr_value::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_ffi_ptr_value {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_ffi_ptr_value {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_ffi_ptr_value);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, Pointer, TypedArray(CType::Uint32), CallbackOptions],
-                    CType::Void,
-                    Self::op_ffi_ptr_value_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_ffi_ptr_value {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_ffi_ptr_value)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(ptr: *mut c_void, out: &mut [u32]) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = {
-            let value = args.get(0usize as i32);
-            if value.is_null() {
-                std::ptr::null_mut()
-            } else if let Ok(b) = deno_core::v8::Local::<
-                deno_core::v8::External,
-            >::try_from(value) {
-                b.value()
-            } else {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected External at position {}", 0usize),
-                );
-            }
-        };
-        let arg_1 = if let Ok(view) = deno_core::v8::Local::<
-            deno_core::v8::Uint32Array,
-        >::try_from(args.get(1usize as i32)) {
-            let (offset, len) = (view.byte_offset(), view.byte_length());
-            let buffer = match view.buffer(scope) {
-                Some(v) => v,
-                None => {
-                    return deno_core::_ops::throw_type_error(
-                        scope,
-                        format!("Expected Uint32Array at position {}", 1usize),
-                    );
-                }
-            };
-            if let Some(data) = buffer.data() {
-                let store = data.cast::<u8>().as_ptr();
-                unsafe {
-                    ::std::slice::from_raw_parts_mut(
-                        store.add(offset) as *mut u32,
-                        len / 4,
-                    )
-                }
-            } else {
-                &mut []
-            }
-        } else {
-            return deno_core::_ops::throw_type_error(
-                scope,
-                format!("Expected Uint32Array at position {}", 1usize),
-            );
-        };
-        let result = Self::call(arg_0, arg_1);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl op_ffi_ptr_value {
-    #[allow(clippy::too_many_arguments)]
-    fn op_ffi_ptr_value_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        ptr: *mut ::std::ffi::c_void,
-        out: *const deno_core::v8::fast_api::FastApiTypedArray<u32>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let out = match unsafe { &*out }.get_storage_if_aligned() {
-            Some(v) => v,
-            None => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-            }
-        };
-        let result = Self::call(ptr, out);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/op_ffi_ptr_value.rs b/ops/optimizer_tests/op_ffi_ptr_value.rs
deleted file mode 100644
index 4c33645..0000000
--- a/ops/optimizer_tests/op_ffi_ptr_value.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub fn op_ffi_ptr_value(ptr: *mut c_void, out: &mut [u32]) {
-  // ...
-}
diff --git a/ops/optimizer_tests/op_print.expected b/ops/optimizer_tests/op_print.expected
deleted file mode 100644
index 6095c13..0000000
--- a/ops/optimizer_tests/op_print.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(Void)
-fast_parameters: [V8Value, SeqOneByteString, Bool]
-transforms: {1: Transform { kind: SeqOneByteString(Ref), index: 1 }}
-is_async: false
-fast_compatible: false
diff --git a/ops/optimizer_tests/op_print.out b/ops/optimizer_tests/op_print.out
deleted file mode 100644
index 784da3e..0000000
--- a/ops/optimizer_tests/op_print.out
+++ /dev/null
@@ -1,102 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_print::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_print {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_print {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_print);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_print {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_print)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(
-        state: &mut OpState,
-        msg: &str,
-        is_err: bool,
-    ) -> Result<(), AnyError> {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = match deno_core::v8::Local::<
-            deno_core::v8::String,
-        >::try_from(args.get(0usize as i32)) {
-            Ok(v8_string) => deno_core::serde_v8::to_utf8(v8_string, scope),
-            Err(_) => {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected string at position {}", 0usize),
-                );
-            }
-        };
-        let arg_0 = arg_0.as_ref();
-        let arg_1 = args.get(1usize as i32);
-        let arg_1 = match deno_core::serde_v8::from_v8(scope, arg_1) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 1usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-            arg_1,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {}
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/op_print.rs b/ops/optimizer_tests/op_print.rs
deleted file mode 100644
index 776ee84..0000000
--- a/ops/optimizer_tests/op_print.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-fn op_print(
-  state: &mut OpState,
-  msg: &str,
-  is_err: bool,
-) -> Result<(), AnyError> {
-  // TODO(@littledivy): fast compatible https://github.com/denoland/deno/issues/17159
-}
diff --git a/ops/optimizer_tests/op_state.expected b/ops/optimizer_tests/op_state.expected
deleted file mode 100644
index 241ea76..0000000
--- a/ops/optimizer_tests/op_state.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value, I32]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_state.out b/ops/optimizer_tests/op_state.out
deleted file mode 100644
index adffc77..0000000
--- a/ops/optimizer_tests/op_state.out
+++ /dev/null
@@ -1,107 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_set_exit_code::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_set_exit_code {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_set_exit_code {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_set_exit_code);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, Int32, CallbackOptions],
-                    CType::Void,
-                    Self::op_set_exit_code_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_set_exit_code {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_set_exit_code)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(state: &mut OpState, code: i32) {
-        state.borrow_mut::<ExitCode>().set(code);
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl op_set_exit_code {
-    #[allow(clippy::too_many_arguments)]
-    fn op_set_exit_code_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        code: i32,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(state, code);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/op_state.rs b/ops/optimizer_tests/op_state.rs
deleted file mode 100644
index 04e9a88..0000000
--- a/ops/optimizer_tests/op_state.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_set_exit_code(state: &mut OpState, code: i32) {
-  state.borrow_mut::<ExitCode>().set(code);
-}
diff --git a/ops/optimizer_tests/op_state_basic1.expected b/ops/optimizer_tests/op_state_basic1.expected
deleted file mode 100644
index e325dd2..0000000
--- a/ops/optimizer_tests/op_state_basic1.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(U32)
-fast_parameters: [V8Value, U32, U32]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_state_basic1.out b/ops/optimizer_tests/op_state_basic1.out
deleted file mode 100644
index 4861554..0000000
--- a/ops/optimizer_tests/op_state_basic1.out
+++ /dev/null
@@ -1,132 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `foo::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct foo {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for foo {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(foo);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, Uint32, Uint32, CallbackOptions],
-                    CType::Uint32,
-                    Self::foo_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl foo {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(foo)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(state: &mut OpState, a: u32, b: u32) -> u32 {
-        a + b
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_1 = args.get(1usize as i32);
-        let arg_1 = match deno_core::serde_v8::from_v8(scope, arg_1) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 1usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-            arg_1,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match deno_core::serde_v8::to_v8(scope, result) {
-            Ok(ret) => rv.set(ret),
-            Err(err) => {
-                deno_core::_ops::throw_type_error(
-                    scope,
-                    format!(
-                        "Error serializing return: {}",
-                        deno_core::anyhow::Error::from(err)
-                    ),
-                )
-            }
-        };
-    }
-}
-impl foo {
-    #[allow(clippy::too_many_arguments)]
-    fn foo_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        a: u32,
-        b: u32,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> u32 {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(state, a, b);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/op_state_basic1.rs b/ops/optimizer_tests/op_state_basic1.rs
deleted file mode 100644
index 9c89b41..0000000
--- a/ops/optimizer_tests/op_state_basic1.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn foo(state: &mut OpState, a: u32, b: u32) -> u32 {
-  a + b
-}
diff --git a/ops/optimizer_tests/op_state_generics.expected b/ops/optimizer_tests/op_state_generics.expected
deleted file mode 100644
index c29258d..0000000
--- a/ops/optimizer_tests/op_state_generics.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_state_generics.out b/ops/optimizer_tests/op_state_generics.out
deleted file mode 100644
index 1315644..0000000
--- a/ops/optimizer_tests/op_state_generics.out
+++ /dev/null
@@ -1,99 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_foo::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_foo<SP> {
-    _phantom_data: ::std::marker::PhantomData<(SP)>,
-}
-impl<SP> deno_core::_ops::Op for op_foo<SP>
-where
-    SP: SomePermission + 'static,
-{
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_foo);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        0usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, CallbackOptions],
-                    CType::Void,
-                    Self::op_foo_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl<SP> op_foo<SP>
-where
-    SP: SomePermission + 'static,
-{
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_foo)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(state: &mut OpState) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let result = Self::call(&mut ::std::cell::RefCell::borrow_mut(&ctx.state));
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl<SP> op_foo<SP>
-where
-    SP: SomePermission + 'static,
-{
-    #[allow(clippy::too_many_arguments)]
-    fn op_foo_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(state);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/op_state_generics.rs b/ops/optimizer_tests/op_state_generics.rs
deleted file mode 100644
index 7fa4989..0000000
--- a/ops/optimizer_tests/op_state_generics.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub fn op_foo<SP>(state: &mut OpState)
-where
-  SP: SomePermission + 'static,
-{
-}
diff --git a/ops/optimizer_tests/op_state_result.expected b/ops/optimizer_tests/op_state_result.expected
deleted file mode 100644
index 15ac033..0000000
--- a/ops/optimizer_tests/op_state_result.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(U32)
-fast_parameters: [V8Value, U32, U32]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_state_result.out b/ops/optimizer_tests/op_state_result.out
deleted file mode 100644
index 09eac34..0000000
--- a/ops/optimizer_tests/op_state_result.out
+++ /dev/null
@@ -1,152 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `foo::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct foo {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for foo {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(foo);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, Uint32, Uint32, CallbackOptions],
-                    CType::Uint32,
-                    Self::foo_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl foo {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(foo)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(state: &mut OpState, a: u32, b: u32) -> Result<u32, AnyError> {
-        Ok(a + b)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        {
-            let op_state = &mut ::std::cell::RefCell::borrow_mut(&ctx.state);
-            if let Some(err) = op_state.last_fast_op_error.take() {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-                return;
-            }
-        }
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_1 = args.get(1usize as i32);
-        let arg_1 = match deno_core::serde_v8::from_v8(scope, arg_1) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 1usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-            arg_1,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {
-                rv.set_uint32(result as u32);
-            }
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
-impl foo {
-    #[allow(clippy::too_many_arguments)]
-    fn foo_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        a: u32,
-        b: u32,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> u32 {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(state, a, b);
-        match result {
-            Ok(result) => result,
-            Err(err) => {
-                state.last_fast_op_error.replace(err);
-                __opts.fallback = true;
-                Default::default()
-            }
-        }
-    }
-}
diff --git a/ops/optimizer_tests/op_state_result.rs b/ops/optimizer_tests/op_state_result.rs
deleted file mode 100644
index 331005c..0000000
--- a/ops/optimizer_tests/op_state_result.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn foo(state: &mut OpState, a: u32, b: u32) -> Result<u32, AnyError> {
-  Ok(a + b)
-}
diff --git a/ops/optimizer_tests/op_state_warning.expected b/ops/optimizer_tests/op_state_warning.expected
deleted file mode 100644
index 7b33ad1..0000000
--- a/ops/optimizer_tests/op_state_warning.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(U32)
-fast_parameters: [V8Value]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_state_warning.out b/ops/optimizer_tests/op_state_warning.out
deleted file mode 100644
index 5e35fe6..0000000
--- a/ops/optimizer_tests/op_state_warning.out
+++ /dev/null
@@ -1,141 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_listen::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_listen {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_listen {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_listen);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        0usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, CallbackOptions],
-                    CType::Uint32,
-                    Self::op_listen_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_listen {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_listen)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(state: &mut OpState) -> Result<ResourceId, Error> {
-        log::debug!("listen");
-        let addr = "127.0.0.1:4570".parse::<SocketAddr>().unwrap();
-        let std_listener = std::net::TcpListener::bind(&addr)?;
-        std_listener.set_nonblocking(true)?;
-        let listener = TcpListener::try_from(std_listener)?;
-        let rid = state.resource_table.add(listener);
-        Ok(rid)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        {
-            let op_state = &mut ::std::cell::RefCell::borrow_mut(&ctx.state);
-            if let Some(err) = op_state.last_fast_op_error.take() {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-                return;
-            }
-        }
-        let result = Self::call(&mut ::std::cell::RefCell::borrow_mut(&ctx.state));
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {
-                match deno_core::serde_v8::to_v8(scope, result) {
-                    Ok(ret) => rv.set(ret),
-                    Err(err) => {
-                        deno_core::_ops::throw_type_error(
-                            scope,
-                            format!(
-                                "Error serializing return: {}",
-                                deno_core::anyhow::Error::from(err)
-                            ),
-                        )
-                    }
-                };
-            }
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
-impl op_listen {
-    #[allow(clippy::too_many_arguments)]
-    fn op_listen_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> u32 {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(state);
-        match result {
-            Ok(result) => result,
-            Err(err) => {
-                state.last_fast_op_error.replace(err);
-                __opts.fallback = true;
-                Default::default()
-            }
-        }
-    }
-}
diff --git a/ops/optimizer_tests/op_state_warning.rs b/ops/optimizer_tests/op_state_warning.rs
deleted file mode 100644
index a725e6f..0000000
--- a/ops/optimizer_tests/op_state_warning.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-fn op_listen(state: &mut OpState) -> Result<ResourceId, Error> {
-  log::debug!("listen");
-  let addr = "127.0.0.1:4570".parse::<SocketAddr>().unwrap();
-  let std_listener = std::net::TcpListener::bind(&addr)?;
-  std_listener.set_nonblocking(true)?;
-  let listener = TcpListener::try_from(std_listener)?;
-  let rid = state.resource_table.add(listener);
-  Ok(rid)
-}
diff --git a/ops/optimizer_tests/op_state_with_transforms.expected b/ops/optimizer_tests/op_state_with_transforms.expected
deleted file mode 100644
index f5f236b..0000000
--- a/ops/optimizer_tests/op_state_with_transforms.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value, Uint8Array]
-transforms: {1: Transform { kind: SliceU8(true), index: 1 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/op_state_with_transforms.out b/ops/optimizer_tests/op_state_with_transforms.out
deleted file mode 100644
index 095b207..0000000
--- a/ops/optimizer_tests/op_state_with_transforms.out
+++ /dev/null
@@ -1,148 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_now::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_now<TP> {
-    _phantom_data: ::std::marker::PhantomData<(TP)>,
-}
-impl<TP> deno_core::_ops::Op for op_now<TP>
-where
-    TP: TimersPermission + 'static,
-{
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_now);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, TypedArray(CType::Uint8), CallbackOptions],
-                    CType::Void,
-                    Self::op_now_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl<TP> op_now<TP>
-where
-    TP: TimersPermission + 'static,
-{
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_now)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(state: &mut OpState, buf: &mut [u8]) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = {
-            let value = args.get(0usize as i32);
-            match deno_core::v8::Local::<deno_core::v8::ArrayBuffer>::try_from(value) {
-                Ok(b) => {
-                    let byte_length = b.byte_length();
-                    if let Some(data) = b.data() {
-                        let store = data.cast::<u8>().as_ptr();
-                        unsafe { ::std::slice::from_raw_parts_mut(store, byte_length) }
-                    } else {
-                        &mut []
-                    }
-                }
-                Err(_) => {
-                    if let Ok(view) = deno_core::v8::Local::<
-                        deno_core::v8::ArrayBufferView,
-                    >::try_from(value) {
-                        let len = view.byte_length();
-                        let offset = view.byte_offset();
-                        let buffer = match view.buffer(scope) {
-                            Some(v) => v,
-                            None => {
-                                return deno_core::_ops::throw_type_error(
-                                    scope,
-                                    format!("Expected ArrayBufferView at position {}", 0usize),
-                                );
-                            }
-                        };
-                        if let Some(data) = buffer.data() {
-                            let store = data.cast::<u8>().as_ptr();
-                            unsafe {
-                                ::std::slice::from_raw_parts_mut(store.add(offset), len)
-                            }
-                        } else {
-                            &mut []
-                        }
-                    } else {
-                        return deno_core::_ops::throw_type_error(
-                            scope,
-                            format!("Expected ArrayBufferView at position {}", 0usize),
-                        );
-                    }
-                }
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl<TP> op_now<TP>
-where
-    TP: TimersPermission + 'static,
-{
-    #[allow(clippy::too_many_arguments)]
-    fn op_now_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        buf: *const deno_core::v8::fast_api::FastApiTypedArray<u8>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let buf = unsafe { (&*buf).get_storage_if_aligned().unwrap_unchecked() };
-        let result = Self::call(state, buf);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/op_state_with_transforms.rs b/ops/optimizer_tests/op_state_with_transforms.rs
deleted file mode 100644
index 4e7e616..0000000
--- a/ops/optimizer_tests/op_state_with_transforms.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub fn op_now<TP>(state: &mut OpState, buf: &mut [u8])
-where
-  TP: TimersPermission + 'static,
-{
-}
diff --git a/ops/optimizer_tests/opstate_with_arity.expected b/ops/optimizer_tests/opstate_with_arity.expected
deleted file mode 100644
index b38455d..0000000
--- a/ops/optimizer_tests/opstate_with_arity.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(U32)
-fast_parameters: [V8Value, U32, U32, U32, U32]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/opstate_with_arity.out b/ops/optimizer_tests/opstate_with_arity.out
deleted file mode 100644
index 6b20d67..0000000
--- a/ops/optimizer_tests/opstate_with_arity.out
+++ /dev/null
@@ -1,172 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_add_4::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_add_4 {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_add_4 {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_add_4);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        4usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, Uint32, Uint32, Uint32, Uint32, CallbackOptions],
-                    CType::Uint32,
-                    Self::op_add_4_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_add_4 {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_add_4)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(x1: u32, x2: u32, x3: u32, x4: u32) -> Result<u32, anyhow::Error> {
-        Ok(x1 + x2 + x3 + x4)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        {
-            let op_state = &mut ::std::cell::RefCell::borrow_mut(&ctx.state);
-            if let Some(err) = op_state.last_fast_op_error.take() {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-                return;
-            }
-        }
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_1 = args.get(1usize as i32);
-        let arg_1 = match deno_core::serde_v8::from_v8(scope, arg_1) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 1usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_2 = args.get(2usize as i32);
-        let arg_2 = match deno_core::serde_v8::from_v8(scope, arg_2) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 2usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_3 = args.get(3usize as i32);
-        let arg_3 = match deno_core::serde_v8::from_v8(scope, arg_3) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 3usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(arg_0, arg_1, arg_2, arg_3);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {
-                rv.set_uint32(result as u32);
-            }
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
-impl op_add_4 {
-    #[allow(clippy::too_many_arguments)]
-    fn op_add_4_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        x1: u32,
-        x2: u32,
-        x3: u32,
-        x4: u32,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> u32 {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let op_state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(x1, x2, x3, x4);
-        match result {
-            Ok(result) => result,
-            Err(err) => {
-                op_state.last_fast_op_error.replace(err);
-                __opts.fallback = true;
-                Default::default()
-            }
-        }
-    }
-}
diff --git a/ops/optimizer_tests/opstate_with_arity.rs b/ops/optimizer_tests/opstate_with_arity.rs
deleted file mode 100644
index 7212ca9..0000000
--- a/ops/optimizer_tests/opstate_with_arity.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_add_4(x1: u32, x2: u32, x3: u32, x4: u32) -> Result<u32, anyhow::Error> {
-  Ok(x1 + x2 + x3 + x4)
-}
diff --git a/ops/optimizer_tests/option_arg.expected b/ops/optimizer_tests/option_arg.expected
deleted file mode 100644
index 250ff10..0000000
--- a/ops/optimizer_tests/option_arg.expected
+++ /dev/null
@@ -1,1 +0,0 @@
-FastUnsupportedParamType
\ No newline at end of file
diff --git a/ops/optimizer_tests/option_arg.out b/ops/optimizer_tests/option_arg.out
deleted file mode 100644
index 6ee3cb7..0000000
--- a/ops/optimizer_tests/option_arg.out
+++ /dev/null
@@ -1,88 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_try_close::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_try_close {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_try_close {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_try_close);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_try_close {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_try_close)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(
-        state: &mut OpState,
-        rid: Option<ResourceId>,
-    ) -> Result<(), Error> {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {}
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/option_arg.rs b/ops/optimizer_tests/option_arg.rs
deleted file mode 100644
index 47a0297..0000000
--- a/ops/optimizer_tests/option_arg.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub fn op_try_close(
-  state: &mut OpState,
-  rid: Option<ResourceId>,
-) -> Result<(), Error> {
-  // ...
-}
diff --git a/ops/optimizer_tests/owned_string.expected b/ops/optimizer_tests/owned_string.expected
deleted file mode 100644
index 4c47a05..0000000
--- a/ops/optimizer_tests/owned_string.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(U32)
-fast_parameters: [V8Value, SeqOneByteString]
-transforms: {0: Transform { kind: SeqOneByteString(Owned), index: 0 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/owned_string.out b/ops/optimizer_tests/owned_string.out
deleted file mode 100644
index ff68ec0..0000000
--- a/ops/optimizer_tests/owned_string.out
+++ /dev/null
@@ -1,115 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_string_length::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_string_length {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_string_length {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_string_length);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, SeqOneByteString, CallbackOptions],
-                    CType::Uint32,
-                    Self::op_string_length_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_string_length {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_string_length)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(string: String) -> u32 {
-        string.len() as u32
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = match deno_core::v8::Local::<
-            deno_core::v8::String,
-        >::try_from(args.get(0usize as i32)) {
-            Ok(v8_string) => deno_core::serde_v8::to_utf8(v8_string, scope),
-            Err(_) => {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected string at position {}", 0usize),
-                );
-            }
-        };
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match deno_core::serde_v8::to_v8(scope, result) {
-            Ok(ret) => rv.set(ret),
-            Err(err) => {
-                deno_core::_ops::throw_type_error(
-                    scope,
-                    format!(
-                        "Error serializing return: {}",
-                        deno_core::anyhow::Error::from(err)
-                    ),
-                )
-            }
-        };
-    }
-}
-impl op_string_length {
-    #[allow(clippy::too_many_arguments)]
-    fn op_string_length_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        string: *const deno_core::v8::fast_api::FastApiOneByteString,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> u32 {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let string = match ::std::str::from_utf8(unsafe { &*string }.as_bytes()) {
-            Ok(v) => v.to_owned(),
-            Err(_) => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-            }
-        };
-        let result = Self::call(string);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/owned_string.rs b/ops/optimizer_tests/owned_string.rs
deleted file mode 100644
index 102cf00..0000000
--- a/ops/optimizer_tests/owned_string.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_string_length(string: String) -> u32 {
-  string.len() as u32
-}
diff --git a/ops/optimizer_tests/param_mut_binding_warning.expected b/ops/optimizer_tests/param_mut_binding_warning.expected
deleted file mode 100644
index 250ff10..0000000
--- a/ops/optimizer_tests/param_mut_binding_warning.expected
+++ /dev/null
@@ -1,1 +0,0 @@
-FastUnsupportedParamType
\ No newline at end of file
diff --git a/ops/optimizer_tests/param_mut_binding_warning.out b/ops/optimizer_tests/param_mut_binding_warning.out
deleted file mode 100644
index 53bd030..0000000
--- a/ops/optimizer_tests/param_mut_binding_warning.out
+++ /dev/null
@@ -1,105 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_read_sync::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_read_sync {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_read_sync {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_read_sync);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_read_sync {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_read_sync)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(
-        state: &mut OpState,
-        rid: ResourceId,
-        mut buf: ZeroCopyBuf,
-    ) -> Result<u32, AnyError> {
-        Ok(23)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_1 = args.get(1usize as i32);
-        let arg_1 = match deno_core::serde_v8::from_v8(scope, arg_1) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 1usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-            arg_1,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {
-                rv.set_uint32(result as u32);
-            }
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/param_mut_binding_warning.rs b/ops/optimizer_tests/param_mut_binding_warning.rs
deleted file mode 100644
index c471227..0000000
--- a/ops/optimizer_tests/param_mut_binding_warning.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-fn op_read_sync(
-  state: &mut OpState,
-  rid: ResourceId,
-  mut buf: ZeroCopyBuf,
-) -> Result<u32, AnyError> {
-  // Should not warn about unused `mut buf` binding.
-  //
-  // This was caused due to incorrect codegen by fast_call.rs
-  // on an incompatible op function.
-  Ok(23)
-}
diff --git a/ops/optimizer_tests/raw_ptr.expected b/ops/optimizer_tests/raw_ptr.expected
deleted file mode 100644
index badd6e3..0000000
--- a/ops/optimizer_tests/raw_ptr.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(Void)
-fast_parameters: [V8Value, Uint8Array, Uint32Array]
-transforms: {1: Transform { kind: PtrU8, index: 1 }, 2: Transform { kind: SliceU32(true), index: 2 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/raw_ptr.out b/ops/optimizer_tests/raw_ptr.out
deleted file mode 100644
index 2e418e3..0000000
--- a/ops/optimizer_tests/raw_ptr.out
+++ /dev/null
@@ -1,188 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_ffi_ptr_of::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_ffi_ptr_of<FP> {
-    _phantom_data: ::std::marker::PhantomData<(FP)>,
-}
-impl<FP> deno_core::_ops::Op for op_ffi_ptr_of<FP>
-where
-    FP: FfiPermissions + 'static,
-{
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_ffi_ptr_of);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[
-                        V8Value,
-                        TypedArray(CType::Uint8),
-                        TypedArray(CType::Uint32),
-                        CallbackOptions,
-                    ],
-                    CType::Void,
-                    Self::op_ffi_ptr_of_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl<FP> op_ffi_ptr_of<FP>
-where
-    FP: FfiPermissions + 'static,
-{
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_ffi_ptr_of)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(state: &mut OpState, buf: *const u8, out: &mut [u32]) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = {
-            let value = args.get(0usize as i32);
-            match deno_core::v8::Local::<deno_core::v8::ArrayBuffer>::try_from(value) {
-                Ok(b) => {
-                    if let Some(data) = b.data() {
-                        data.cast::<u8>().as_ptr()
-                    } else {
-                        std::ptr::null::<u8>()
-                    }
-                }
-                Err(_) => {
-                    if let Ok(view) = deno_core::v8::Local::<
-                        deno_core::v8::ArrayBufferView,
-                    >::try_from(value) {
-                        let offset = view.byte_offset();
-                        let buffer = match view.buffer(scope) {
-                            Some(v) => v,
-                            None => {
-                                return deno_core::_ops::throw_type_error(
-                                    scope,
-                                    format!("Expected ArrayBufferView at position {}", 0usize),
-                                );
-                            }
-                        };
-                        let store = if let Some(data) = buffer.data() {
-                            data.cast::<u8>().as_ptr()
-                        } else {
-                            std::ptr::null_mut::<u8>()
-                        };
-                        unsafe { store.add(offset) }
-                    } else {
-                        return deno_core::_ops::throw_type_error(
-                            scope,
-                            format!("Expected ArrayBufferView at position {}", 0usize),
-                        );
-                    }
-                }
-            }
-        };
-        let arg_1 = if let Ok(view) = deno_core::v8::Local::<
-            deno_core::v8::Uint32Array,
-        >::try_from(args.get(1usize as i32)) {
-            let (offset, len) = (view.byte_offset(), view.byte_length());
-            let buffer = match view.buffer(scope) {
-                Some(v) => v,
-                None => {
-                    return deno_core::_ops::throw_type_error(
-                        scope,
-                        format!("Expected Uint32Array at position {}", 1usize),
-                    );
-                }
-            };
-            if let Some(data) = buffer.data() {
-                let store = data.cast::<u8>().as_ptr();
-                unsafe {
-                    ::std::slice::from_raw_parts_mut(
-                        store.add(offset) as *mut u32,
-                        len / 4,
-                    )
-                }
-            } else {
-                &mut []
-            }
-        } else {
-            return deno_core::_ops::throw_type_error(
-                scope,
-                format!("Expected Uint32Array at position {}", 1usize),
-            );
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-            arg_1,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl<FP> op_ffi_ptr_of<FP>
-where
-    FP: FfiPermissions + 'static,
-{
-    #[allow(clippy::too_many_arguments)]
-    fn op_ffi_ptr_of_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        buf: *const deno_core::v8::fast_api::FastApiTypedArray<u8>,
-        out: *const deno_core::v8::fast_api::FastApiTypedArray<u32>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let buf = unsafe { (&*buf).get_storage_if_aligned().unwrap_unchecked() }
-            .as_ptr();
-        let out = match unsafe { &*out }.get_storage_if_aligned() {
-            Some(v) => v,
-            None => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-            }
-        };
-        let result = Self::call(state, buf, out);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/raw_ptr.rs b/ops/optimizer_tests/raw_ptr.rs
deleted file mode 100644
index 249b3b3..0000000
--- a/ops/optimizer_tests/raw_ptr.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-fn op_ffi_ptr_of<FP>(state: &mut OpState, buf: *const u8, out: &mut [u32])
-where
-  FP: FfiPermissions + 'static,
-{
-  // ..
-}
diff --git a/ops/optimizer_tests/serde_v8_value.expected b/ops/optimizer_tests/serde_v8_value.expected
deleted file mode 100644
index 411fbec..0000000
--- a/ops/optimizer_tests/serde_v8_value.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Bool)
-fast_parameters: [V8Value, V8Value]
-transforms: {0: Transform { kind: V8Value, index: 0 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/serde_v8_value.out b/ops/optimizer_tests/serde_v8_value.out
deleted file mode 100644
index 4a76fa2..0000000
--- a/ops/optimizer_tests/serde_v8_value.out
+++ /dev/null
@@ -1,108 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_is_proxy::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_is_proxy {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_is_proxy {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_is_proxy);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, V8Value],
-                    CType::Bool,
-                    Self::op_is_proxy_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_is_proxy {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_is_proxy)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(value: serde_v8::Value) -> bool {
-        value.v8_value.is_proxy()
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match deno_core::serde_v8::to_v8(scope, result) {
-            Ok(ret) => rv.set(ret),
-            Err(err) => {
-                deno_core::_ops::throw_type_error(
-                    scope,
-                    format!(
-                        "Error serializing return: {}",
-                        deno_core::anyhow::Error::from(err)
-                    ),
-                )
-            }
-        };
-    }
-}
-impl op_is_proxy {
-    #[allow(clippy::too_many_arguments)]
-    fn op_is_proxy_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        value: deno_core::v8::Local<deno_core::v8::Value>,
-    ) -> bool {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let value = serde_v8::Value { v8_value: value };
-        let result = Self::call(value);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/serde_v8_value.rs b/ops/optimizer_tests/serde_v8_value.rs
deleted file mode 100644
index c986930..0000000
--- a/ops/optimizer_tests/serde_v8_value.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_is_proxy(value: serde_v8::Value) -> bool {
-  value.v8_value.is_proxy()
-}
diff --git a/ops/optimizer_tests/strings.expected b/ops/optimizer_tests/strings.expected
deleted file mode 100644
index 4a6bb15..0000000
--- a/ops/optimizer_tests/strings.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(U32)
-fast_parameters: [V8Value, SeqOneByteString]
-transforms: {0: Transform { kind: SeqOneByteString(Ref), index: 0 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/strings.out b/ops/optimizer_tests/strings.out
deleted file mode 100644
index a1ea053..0000000
--- a/ops/optimizer_tests/strings.out
+++ /dev/null
@@ -1,116 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_string_length::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_string_length {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_string_length {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_string_length);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, SeqOneByteString, CallbackOptions],
-                    CType::Uint32,
-                    Self::op_string_length_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_string_length {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_string_length)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(string: &str) -> u32 {
-        string.len() as u32
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = match deno_core::v8::Local::<
-            deno_core::v8::String,
-        >::try_from(args.get(0usize as i32)) {
-            Ok(v8_string) => deno_core::serde_v8::to_utf8(v8_string, scope),
-            Err(_) => {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected string at position {}", 0usize),
-                );
-            }
-        };
-        let arg_0 = arg_0.as_ref();
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match deno_core::serde_v8::to_v8(scope, result) {
-            Ok(ret) => rv.set(ret),
-            Err(err) => {
-                deno_core::_ops::throw_type_error(
-                    scope,
-                    format!(
-                        "Error serializing return: {}",
-                        deno_core::anyhow::Error::from(err)
-                    ),
-                )
-            }
-        };
-    }
-}
-impl op_string_length {
-    #[allow(clippy::too_many_arguments)]
-    fn op_string_length_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        string: *const deno_core::v8::fast_api::FastApiOneByteString,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> u32 {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let string = match ::std::str::from_utf8(unsafe { &*string }.as_bytes()) {
-            Ok(v) => v,
-            Err(_) => {
-                unsafe { &mut *fast_api_callback_options }.fallback = true;
-                return Default::default();
-            }
-        };
-        let result = Self::call(string);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/strings.rs b/ops/optimizer_tests/strings.rs
deleted file mode 100644
index 860f1e8..0000000
--- a/ops/optimizer_tests/strings.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_string_length(string: &str) -> u32 {
-  string.len() as u32
-}
diff --git a/ops/optimizer_tests/strings_result.expected b/ops/optimizer_tests/strings_result.expected
deleted file mode 100644
index 3866751..0000000
--- a/ops/optimizer_tests/strings_result.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: true
-fast_result: Some(U32)
-fast_parameters: [V8Value, SeqOneByteString]
-transforms: {0: Transform { kind: SeqOneByteString(Ref), index: 0 }}
-is_async: false
-fast_compatible: false
diff --git a/ops/optimizer_tests/strings_result.out b/ops/optimizer_tests/strings_result.out
deleted file mode 100644
index 3eca689..0000000
--- a/ops/optimizer_tests/strings_result.out
+++ /dev/null
@@ -1,87 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_string_length::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_string_length {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_string_length {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_string_length);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_string_length {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_string_length)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(string: &str) -> Result<u32, AnyError> {
-        Ok(string.len() as u32)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = match deno_core::v8::Local::<
-            deno_core::v8::String,
-        >::try_from(args.get(0usize as i32)) {
-            Ok(v8_string) => deno_core::serde_v8::to_utf8(v8_string, scope),
-            Err(_) => {
-                return deno_core::_ops::throw_type_error(
-                    scope,
-                    format!("Expected string at position {}", 0usize),
-                );
-            }
-        };
-        let arg_0 = arg_0.as_ref();
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {
-                rv.set_uint32(result as u32);
-            }
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/strings_result.rs b/ops/optimizer_tests/strings_result.rs
deleted file mode 100644
index f89efaa..0000000
--- a/ops/optimizer_tests/strings_result.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-// https://github.com/denoland/deno/issues/16979
-fn op_string_length(string: &str) -> Result<u32, AnyError> {
-  Ok(string.len() as u32)
-}
diff --git a/ops/optimizer_tests/u64_result.expected b/ops/optimizer_tests/u64_result.expected
deleted file mode 100644
index 250ff10..0000000
--- a/ops/optimizer_tests/u64_result.expected
+++ /dev/null
@@ -1,1 +0,0 @@
-FastUnsupportedParamType
\ No newline at end of file
diff --git a/ops/optimizer_tests/u64_result.out b/ops/optimizer_tests/u64_result.out
deleted file mode 100644
index e31d6c0..0000000
--- a/ops/optimizer_tests/u64_result.out
+++ /dev/null
@@ -1,88 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_bench_now::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_bench_now {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_bench_now {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_bench_now);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        0usize as u8,
-        Self::v8_fn_ptr as _,
-        None,
-    );
-}
-#[doc(hidden)]
-impl op_bench_now {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_bench_now)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(state: &mut OpState) -> Result<u64, AnyError> {
-        let ns = state.borrow::<time::Instant>().elapsed().as_nanos();
-        let ns_u64 = u64::try_from(ns)?;
-        Ok(ns_u64)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let result = Self::call(&mut ::std::cell::RefCell::borrow_mut(&ctx.state));
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {
-                match deno_core::serde_v8::to_v8(scope, result) {
-                    Ok(ret) => rv.set(ret),
-                    Err(err) => {
-                        deno_core::_ops::throw_type_error(
-                            scope,
-                            format!(
-                                "Error serializing return: {}",
-                                deno_core::anyhow::Error::from(err)
-                            ),
-                        )
-                    }
-                };
-            }
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
diff --git a/ops/optimizer_tests/u64_result.rs b/ops/optimizer_tests/u64_result.rs
deleted file mode 100644
index 1cc783d..0000000
--- a/ops/optimizer_tests/u64_result.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn op_bench_now(state: &mut OpState) -> Result<u64, AnyError> {
-  let ns = state.borrow::<time::Instant>().elapsed().as_nanos();
-  let ns_u64 = u64::try_from(ns)?;
-  Ok(ns_u64)
-}
diff --git a/ops/optimizer_tests/uint8array.expected b/ops/optimizer_tests/uint8array.expected
deleted file mode 100644
index 49554a2..0000000
--- a/ops/optimizer_tests/uint8array.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Bool)
-fast_parameters: [V8Value, Uint8Array, Uint8Array]
-transforms: {0: Transform { kind: SliceU8(false), index: 0 }, 1: Transform { kind: SliceU8(true), index: 1 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/uint8array.out b/ops/optimizer_tests/uint8array.out
deleted file mode 100644
index f88bc96..0000000
--- a/ops/optimizer_tests/uint8array.out
+++ /dev/null
@@ -1,187 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_import_spki_x25519::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_import_spki_x25519 {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_import_spki_x25519 {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_import_spki_x25519);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, TypedArray(CType::Uint8), TypedArray(CType::Uint8)],
-                    CType::Bool,
-                    Self::op_import_spki_x25519_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_import_spki_x25519 {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_import_spki_x25519)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(key_data: &[u8], out: &mut [u8]) -> bool {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = {
-            let value = args.get(0usize as i32);
-            match deno_core::v8::Local::<deno_core::v8::ArrayBuffer>::try_from(value) {
-                Ok(b) => {
-                    let byte_length = b.byte_length();
-                    if let Some(data) = b.data() {
-                        let store = data.cast::<u8>().as_ptr();
-                        unsafe { ::std::slice::from_raw_parts_mut(store, byte_length) }
-                    } else {
-                        &mut []
-                    }
-                }
-                Err(_) => {
-                    if let Ok(view) = deno_core::v8::Local::<
-                        deno_core::v8::ArrayBufferView,
-                    >::try_from(value) {
-                        let len = view.byte_length();
-                        let offset = view.byte_offset();
-                        let buffer = match view.buffer(scope) {
-                            Some(v) => v,
-                            None => {
-                                return deno_core::_ops::throw_type_error(
-                                    scope,
-                                    format!("Expected ArrayBufferView at position {}", 0usize),
-                                );
-                            }
-                        };
-                        if let Some(data) = buffer.data() {
-                            let store = data.cast::<u8>().as_ptr();
-                            unsafe {
-                                ::std::slice::from_raw_parts_mut(store.add(offset), len)
-                            }
-                        } else {
-                            &mut []
-                        }
-                    } else {
-                        return deno_core::_ops::throw_type_error(
-                            scope,
-                            format!("Expected ArrayBufferView at position {}", 0usize),
-                        );
-                    }
-                }
-            }
-        };
-        let arg_1 = {
-            let value = args.get(1usize as i32);
-            match deno_core::v8::Local::<deno_core::v8::ArrayBuffer>::try_from(value) {
-                Ok(b) => {
-                    let byte_length = b.byte_length();
-                    if let Some(data) = b.data() {
-                        let store = data.cast::<u8>().as_ptr();
-                        unsafe { ::std::slice::from_raw_parts_mut(store, byte_length) }
-                    } else {
-                        &mut []
-                    }
-                }
-                Err(_) => {
-                    if let Ok(view) = deno_core::v8::Local::<
-                        deno_core::v8::ArrayBufferView,
-                    >::try_from(value) {
-                        let len = view.byte_length();
-                        let offset = view.byte_offset();
-                        let buffer = match view.buffer(scope) {
-                            Some(v) => v,
-                            None => {
-                                return deno_core::_ops::throw_type_error(
-                                    scope,
-                                    format!("Expected ArrayBufferView at position {}", 1usize),
-                                );
-                            }
-                        };
-                        if let Some(data) = buffer.data() {
-                            let store = data.cast::<u8>().as_ptr();
-                            unsafe {
-                                ::std::slice::from_raw_parts_mut(store.add(offset), len)
-                            }
-                        } else {
-                            &mut []
-                        }
-                    } else {
-                        return deno_core::_ops::throw_type_error(
-                            scope,
-                            format!("Expected ArrayBufferView at position {}", 1usize),
-                        );
-                    }
-                }
-            }
-        };
-        let result = Self::call(arg_0, arg_1);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match deno_core::serde_v8::to_v8(scope, result) {
-            Ok(ret) => rv.set(ret),
-            Err(err) => {
-                deno_core::_ops::throw_type_error(
-                    scope,
-                    format!(
-                        "Error serializing return: {}",
-                        deno_core::anyhow::Error::from(err)
-                    ),
-                )
-            }
-        };
-    }
-}
-impl op_import_spki_x25519 {
-    #[allow(clippy::too_many_arguments)]
-    fn op_import_spki_x25519_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        key_data: *const deno_core::v8::fast_api::FastApiTypedArray<u8>,
-        out: *const deno_core::v8::fast_api::FastApiTypedArray<u8>,
-    ) -> bool {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let key_data = unsafe {
-            (&*key_data).get_storage_if_aligned().unwrap_unchecked()
-        };
-        let out = unsafe { (&*out).get_storage_if_aligned().unwrap_unchecked() };
-        let result = Self::call(key_data, out);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/uint8array.rs b/ops/optimizer_tests/uint8array.rs
deleted file mode 100644
index f4507b2..0000000
--- a/ops/optimizer_tests/uint8array.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub fn op_import_spki_x25519(key_data: &[u8], out: &mut [u8]) -> bool {
-  // ...
-}
diff --git a/ops/optimizer_tests/unit_result.expected b/ops/optimizer_tests/unit_result.expected
deleted file mode 100644
index 693a771..0000000
--- a/ops/optimizer_tests/unit_result.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/unit_result.out b/ops/optimizer_tests/unit_result.out
deleted file mode 100644
index 45e83c6..0000000
--- a/ops/optimizer_tests/unit_result.out
+++ /dev/null
@@ -1,121 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_unit_result::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_unit_result {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_unit_result {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_unit_result);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        0usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, CallbackOptions],
-                    CType::Void,
-                    Self::op_unit_result_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_unit_result {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_unit_result)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>() -> Result<(), AnyError> {
-        Ok(())
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        {
-            let op_state = &mut ::std::cell::RefCell::borrow_mut(&ctx.state);
-            if let Some(err) = op_state.last_fast_op_error.take() {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-                return;
-            }
-        }
-        let result = Self::call();
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {}
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
-impl op_unit_result {
-    #[allow(clippy::too_many_arguments)]
-    fn op_unit_result_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let op_state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call();
-        match result {
-            Ok(result) => result,
-            Err(err) => {
-                op_state.last_fast_op_error.replace(err);
-                __opts.fallback = true;
-            }
-        }
-    }
-}
diff --git a/ops/optimizer_tests/unit_result.rs b/ops/optimizer_tests/unit_result.rs
deleted file mode 100644
index 2078969..0000000
--- a/ops/optimizer_tests/unit_result.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_unit_result() -> Result<(), AnyError> {
-  Ok(())
-}
diff --git a/ops/optimizer_tests/unit_result2.expected b/ops/optimizer_tests/unit_result2.expected
deleted file mode 100644
index d799a77..0000000
--- a/ops/optimizer_tests/unit_result2.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: true
-has_ref_opstate: true
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value, U32, Bool]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/unit_result2.out b/ops/optimizer_tests/unit_result2.out
deleted file mode 100644
index ed73683..0000000
--- a/ops/optimizer_tests/unit_result2.out
+++ /dev/null
@@ -1,156 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_set_nodelay::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_set_nodelay {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_set_nodelay {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_set_nodelay);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        2usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, Uint32, Bool, CallbackOptions],
-                    CType::Void,
-                    Self::op_set_nodelay_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_set_nodelay {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_set_nodelay)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    pub fn call<'scope>(
-        state: &mut OpState,
-        rid: ResourceId,
-        nodelay: bool,
-    ) -> Result<(), AnyError> {
-        let resource: Rc<TcpStreamResource> = state
-            .resource_table
-            .get::<TcpStreamResource>(rid)?;
-        resource.set_nodelay(nodelay)
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        {
-            let op_state = &mut ::std::cell::RefCell::borrow_mut(&ctx.state);
-            if let Some(err) = op_state.last_fast_op_error.take() {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-                return;
-            }
-        }
-        let arg_0 = args.get(0usize as i32);
-        let arg_0 = match deno_core::serde_v8::from_v8(scope, arg_0) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 0usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let arg_1 = args.get(1usize as i32);
-        let arg_1 = match deno_core::serde_v8::from_v8(scope, arg_1) {
-            Ok(v) => v,
-            Err(err) => {
-                let msg = format!(
-                    "Error parsing args at position {}: {}", 1usize,
-                    deno_core::anyhow::Error::from(err)
-                );
-                return deno_core::_ops::throw_type_error(scope, msg);
-            }
-        };
-        let result = Self::call(
-            &mut ::std::cell::RefCell::borrow_mut(&ctx.state),
-            arg_0,
-            arg_1,
-        );
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match result {
-            Ok(result) => {}
-            Err(err) => {
-                let exception = deno_core::error::to_v8_error(
-                    scope,
-                    ctx.get_error_class_fn,
-                    &err,
-                );
-                scope.throw_exception(exception);
-            }
-        };
-    }
-}
-impl op_set_nodelay {
-    #[allow(clippy::too_many_arguments)]
-    fn op_set_nodelay_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        rid: ResourceId,
-        nodelay: bool,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let __ctx = unsafe {
-            &*(v8::Local::<v8::External>::cast(unsafe { __opts.data.data }).value()
-                as *const _ops::OpCtx)
-        };
-        let state = &mut ::std::cell::RefCell::borrow_mut(&__ctx.state);
-        let result = Self::call(state, rid, nodelay);
-        match result {
-            Ok(result) => result,
-            Err(err) => {
-                state.last_fast_op_error.replace(err);
-                __opts.fallback = true;
-            }
-        }
-    }
-}
diff --git a/ops/optimizer_tests/unit_result2.rs b/ops/optimizer_tests/unit_result2.rs
deleted file mode 100644
index 83b73e1..0000000
--- a/ops/optimizer_tests/unit_result2.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn op_set_nodelay(
-  state: &mut OpState,
-  rid: ResourceId,
-  nodelay: bool,
-) -> Result<(), AnyError> {
-  let resource: Rc<TcpStreamResource> =
-    state.resource_table.get::<TcpStreamResource>(rid)?;
-  resource.set_nodelay(nodelay)
-}
diff --git a/ops/optimizer_tests/unit_ret.expected b/ops/optimizer_tests/unit_ret.expected
deleted file mode 100644
index 5d414e1..0000000
--- a/ops/optimizer_tests/unit_ret.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value]
-transforms: {}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/unit_ret.out b/ops/optimizer_tests/unit_ret.out
deleted file mode 100644
index fa3e77e..0000000
--- a/ops/optimizer_tests/unit_ret.out
+++ /dev/null
@@ -1,93 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_unit::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_unit {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_unit {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_unit);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        0usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value],
-                    CType::Void,
-                    Self::op_unit_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_unit {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_unit)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>() -> () {
-        ()
-    }
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let result = Self::call();
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-        match deno_core::serde_v8::to_v8(scope, result) {
-            Ok(ret) => rv.set(ret),
-            Err(err) => {
-                deno_core::_ops::throw_type_error(
-                    scope,
-                    format!(
-                        "Error serializing return: {}",
-                        deno_core::anyhow::Error::from(err)
-                    ),
-                )
-            }
-        };
-    }
-}
-impl op_unit {
-    #[allow(clippy::too_many_arguments)]
-    fn op_unit_fast_fn(_: deno_core::v8::Local<deno_core::v8::Object>) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let result = Self::call();
-        result
-    }
-}
diff --git a/ops/optimizer_tests/unit_ret.rs b/ops/optimizer_tests/unit_ret.rs
deleted file mode 100644
index 4cf3651..0000000
--- a/ops/optimizer_tests/unit_ret.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_unit() -> () {
-  ()
-}
diff --git a/ops/optimizer_tests/wasm_op.expected b/ops/optimizer_tests/wasm_op.expected
deleted file mode 100644
index 8d3719c..0000000
--- a/ops/optimizer_tests/wasm_op.expected
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Optimizer Dump ===
-returns_result: false
-has_ref_opstate: false
-has_rc_opstate: false
-has_fast_callback_option: false
-needs_fast_callback_option: false
-fast_result: Some(Void)
-fast_parameters: [V8Value]
-transforms: {0: Transform { kind: WasmMemory, index: 0 }}
-is_async: false
-fast_compatible: true
diff --git a/ops/optimizer_tests/wasm_op.out b/ops/optimizer_tests/wasm_op.out
deleted file mode 100644
index 0bb8333..0000000
--- a/ops/optimizer_tests/wasm_op.out
+++ /dev/null
@@ -1,91 +0,0 @@
-#[allow(non_camel_case_types)]
-///Auto-generated by `deno_ops`, i.e: `#[op]`
-///
-///Use `op_wasm::decl()` to get an op-declaration
-///you can include in a `deno_core::Extension`.
-pub struct op_wasm {
-    _phantom_data: ::std::marker::PhantomData<()>,
-}
-impl deno_core::_ops::Op for op_wasm {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const NAME: &'static str = stringify!(op_wasm);
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    const DECL: deno_core::OpDecl = deno_core::_ops::OpDecl::new_internal(
-        Self::name(),
-        false,
-        false,
-        false,
-        1usize as u8,
-        Self::v8_fn_ptr as _,
-        {
-            use deno_core::v8::fast_api::CType;
-            use deno_core::v8::fast_api::Type::*;
-            Some(
-                deno_core::v8::fast_api::FastFunction::new(
-                    &[V8Value, CallbackOptions],
-                    CType::Void,
-                    Self::op_wasm_fast_fn as *const ::std::ffi::c_void,
-                ),
-            )
-        },
-    );
-}
-#[doc(hidden)]
-impl op_wasm {
-    #[deprecated = "#[op] is deprecated. Please switch this op to #[op2]."]
-    pub const fn name() -> &'static str {
-        stringify!(op_wasm)
-    }
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub extern "C" fn v8_fn_ptr(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);
-    }
-    #[deprecated(note = "Use the const op::DECL instead")]
-    pub const fn decl() -> deno_core::_ops::OpDecl {
-        <Self as deno_core::_ops::Op>::DECL
-    }
-    #[inline]
-    #[allow(clippy::too_many_arguments)]
-    #[allow(clippy::extra_unused_lifetimes)]
-    fn call<'scope>(memory: Option<&mut [u8]>) {}
-    pub fn v8_func<'scope>(
-        scope: &mut deno_core::v8::HandleScope<'scope>,
-        args: deno_core::v8::FunctionCallbackArguments,
-        mut rv: deno_core::v8::ReturnValue,
-    ) {
-        let ctx = unsafe {
-            &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
-                as *const deno_core::_ops::OpCtx)
-        };
-        let arg_0 = None;
-        let result = Self::call(arg_0);
-        let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
-        op_state.tracker.track_sync(ctx.id);
-    }
-}
-impl op_wasm {
-    #[allow(clippy::too_many_arguments)]
-    fn op_wasm_fast_fn(
-        _: deno_core::v8::Local<deno_core::v8::Object>,
-        fast_api_callback_options: *mut deno_core::v8::fast_api::FastApiCallbackOptions,
-    ) -> () {
-        use deno_core::v8;
-        use deno_core::_ops;
-        let __opts: &mut v8::fast_api::FastApiCallbackOptions = unsafe {
-            &mut *fast_api_callback_options
-        };
-        let memory = unsafe {
-            &*(__opts.wasm_memory
-                as *const deno_core::v8::fast_api::FastApiTypedArray<u8>)
-        }
-            .get_storage_if_aligned();
-        let result = Self::call(memory);
-        result
-    }
-}
diff --git a/ops/optimizer_tests/wasm_op.rs b/ops/optimizer_tests/wasm_op.rs
deleted file mode 100644
index b18f32f..0000000
--- a/ops/optimizer_tests/wasm_op.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn op_wasm(memory: Option<&mut [u8]>) {
-  // @test-attr:wasm
-}