summaryrefslogtreecommitdiff
path: root/ops/optimizer_tests
diff options
context:
space:
mode:
Diffstat (limited to 'ops/optimizer_tests')
-rw-r--r--ops/optimizer_tests/async_nop.out78
-rw-r--r--ops/optimizer_tests/async_result.out137
-rw-r--r--ops/optimizer_tests/callback_options.out53
-rw-r--r--ops/optimizer_tests/incompatible_1.out71
-rw-r--r--ops/optimizer_tests/op_state.out61
-rw-r--r--ops/optimizer_tests/op_state_basic1.out88
-rw-r--r--ops/optimizer_tests/op_state_generics.out60
-rw-r--r--ops/optimizer_tests/op_state_result.out101
-rw-r--r--ops/optimizer_tests/op_state_warning.out92
-rw-r--r--ops/optimizer_tests/op_state_with_transforms.out107
-rw-r--r--ops/optimizer_tests/opstate_with_arity.out119
-rw-r--r--ops/optimizer_tests/param_mut_binding_warning.out89
-rw-r--r--ops/optimizer_tests/raw_ptr.out133
-rw-r--r--ops/optimizer_tests/serde_v8_value.out73
-rw-r--r--ops/optimizer_tests/u64_result.out72
15 files changed, 1334 insertions, 0 deletions
diff --git a/ops/optimizer_tests/async_nop.out b/ops/optimizer_tests/async_nop.out
index 901b8a225..08f7a87a2 100644
--- a/ops/optimizer_tests/async_nop.out
+++ b/ops/optimizer_tests/async_nop.out
@@ -1,3 +1,81 @@
+#[allow(non_camel_case_types)]
+///Auto-generated by `deno_ops`, i.e: `#[op]`
+///
+///Use `op_void_async::decl()` to get an op-declaration
+///you can include in a `deno_core::Extension`.
+pub struct op_void_async;
+#[doc(hidden)]
+impl op_void_async {
+ pub fn name() -> &'static str {
+ stringify!(op_void_async)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_void_async_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: true,
+ is_unstable: false,
+ is_v8: false,
+ argc: 0usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ async fn call() {}
+ pub fn v8_func<'scope>(
+ scope: &mut deno_core::v8::HandleScope<'scope>,
+ args: deno_core::v8::FunctionCallbackArguments,
+ mut rv: deno_core::v8::ReturnValue,
+ ) {
+ use deno_core::futures::FutureExt;
+ let ctx = unsafe {
+ &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
+ as *const deno_core::_ops::OpCtx)
+ };
+ let op_id = ctx.id;
+ let promise_id = args.get(0);
+ let promise_id = deno_core::v8::Local::<
+ deno_core::v8::Integer,
+ >::try_from(promise_id)
+ .map(|l| l.value() as deno_core::PromiseId)
+ .map_err(deno_core::anyhow::Error::from);
+ let promise_id: deno_core::PromiseId = match promise_id {
+ Ok(promise_id) => promise_id,
+ Err(err) => {
+ deno_core::_ops::throw_type_error(
+ scope,
+ format!("invalid promise id: {}", err),
+ );
+ return;
+ }
+ };
+ let get_class = {
+ let state = ::std::cell::RefCell::borrow(&ctx.state);
+ state.tracker.track_async(op_id);
+ state.get_error_class_fn
+ };
+ deno_core::_ops::queue_async_op(
+ ctx,
+ scope,
+ false,
+ async move {
+ let result = Self::call().await;
+ let result = Ok(result);
+ (promise_id, op_id, deno_core::_ops::to_op_result(get_class, result))
+ },
+ );
+ }
+}
struct op_void_async_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/async_result.out b/ops/optimizer_tests/async_result.out
index d312fde73..b9719d22a 100644
--- a/ops/optimizer_tests/async_result.out
+++ b/ops/optimizer_tests/async_result.out
@@ -1,3 +1,140 @@
+#[allow(non_camel_case_types)]
+///Auto-generated by `deno_ops`, i.e: `#[op]`
+///
+///Use `op_read::decl()` to get an op-declaration
+///you can include in a `deno_core::Extension`.
+pub struct op_read;
+#[doc(hidden)]
+impl op_read {
+ pub fn name() -> &'static str {
+ stringify!(op_read)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_read_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: true,
+ is_unstable: false,
+ is_v8: false,
+ argc: 2usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ async fn call(
+ state: Rc<RefCell<OpState>>,
+ rid: ResourceId,
+ buf: &mut [u8],
+ ) -> Result<u32, Error> {}
+ pub fn v8_func<'scope>(
+ scope: &mut deno_core::v8::HandleScope<'scope>,
+ args: deno_core::v8::FunctionCallbackArguments,
+ mut rv: deno_core::v8::ReturnValue,
+ ) {
+ use deno_core::futures::FutureExt;
+ let ctx = unsafe {
+ &*(deno_core::v8::Local::<deno_core::v8::External>::cast(args.data()).value()
+ as *const deno_core::_ops::OpCtx)
+ };
+ let op_id = ctx.id;
+ let promise_id = args.get(0);
+ let promise_id = deno_core::v8::Local::<
+ deno_core::v8::Integer,
+ >::try_from(promise_id)
+ .map(|l| l.value() as deno_core::PromiseId)
+ .map_err(deno_core::anyhow::Error::from);
+ let promise_id: deno_core::PromiseId = match promise_id {
+ Ok(promise_id) => promise_id,
+ Err(err) => {
+ deno_core::_ops::throw_type_error(
+ scope,
+ format!("invalid promise id: {}", err),
+ );
+ return;
+ }
+ };
+ let arg_0 = args.get(1usize 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 {}: {}", 1usize,
+ deno_core::anyhow::Error::from(err)
+ );
+ return deno_core::_ops::throw_type_error(scope, msg);
+ }
+ };
+ let arg_1 = {
+ let value = args.get(2usize 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 {}", 2usize),
+ );
+ }
+ };
+ 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 {}", 2usize),
+ );
+ }
+ }
+ }
+ };
+ let get_class = {
+ let state = ::std::cell::RefCell::borrow(&ctx.state);
+ state.tracker.track_async(op_id);
+ state.get_error_class_fn
+ };
+ deno_core::_ops::queue_async_op(
+ ctx,
+ scope,
+ false,
+ async move {
+ let result = Self::call(ctx.state.clone(), arg_0, arg_1).await;
+ (promise_id, op_id, deno_core::_ops::to_op_result(get_class, result))
+ },
+ );
+ }
+}
struct op_read_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/callback_options.out b/ops/optimizer_tests/callback_options.out
index 426fe0c4a..020cc4a3e 100644
--- a/ops/optimizer_tests/callback_options.out
+++ b/ops/optimizer_tests/callback_options.out
@@ -1,3 +1,56 @@
+#[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;
+#[doc(hidden)]
+impl op_fallback {
+ pub fn name() -> &'static str {
+ stringify!(op_fallback)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_fallback_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 1usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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);
+ }
+}
struct op_fallback_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/incompatible_1.out b/ops/optimizer_tests/incompatible_1.out
new file mode 100644
index 000000000..92cf4a576
--- /dev/null
+++ b/ops/optimizer_tests/incompatible_1.out
@@ -0,0 +1,71 @@
+#[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;
+#[doc(hidden)]
+impl op_sync_serialize_object_with_numbers_as_keys {
+ pub fn name() -> &'static str {
+ stringify!(op_sync_serialize_object_with_numbers_as_keys)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: None,
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 1usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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,
+ op_state.get_error_class_fn,
+ &err,
+ );
+ scope.throw_exception(exception);
+ }
+ };
+ }
+}
diff --git a/ops/optimizer_tests/op_state.out b/ops/optimizer_tests/op_state.out
index a98db68d8..5b273960a 100644
--- a/ops/optimizer_tests/op_state.out
+++ b/ops/optimizer_tests/op_state.out
@@ -1,3 +1,64 @@
+#[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;
+#[doc(hidden)]
+impl op_set_exit_code {
+ pub fn name() -> &'static str {
+ stringify!(op_set_exit_code)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_set_exit_code_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 1usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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);
+ }
+}
struct op_set_exit_code_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/op_state_basic1.out b/ops/optimizer_tests/op_state_basic1.out
index 0f03f2c58..ab3404a42 100644
--- a/ops/optimizer_tests/op_state_basic1.out
+++ b/ops/optimizer_tests/op_state_basic1.out
@@ -1,3 +1,91 @@
+#[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;
+#[doc(hidden)]
+impl foo {
+ pub fn name() -> &'static str {
+ stringify!(foo)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(foo_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 2usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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)
+ ),
+ )
+ }
+ };
+ }
+}
struct foo_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/op_state_generics.out b/ops/optimizer_tests/op_state_generics.out
index d141c7445..bd5e40afe 100644
--- a/ops/optimizer_tests/op_state_generics.out
+++ b/ops/optimizer_tests/op_state_generics.out
@@ -1,3 +1,63 @@
+#[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;
+#[doc(hidden)]
+impl op_foo {
+ pub fn name() -> &'static str {
+ stringify!(op_foo)
+ }
+ pub fn v8_fn_ptr<'scope, SP>() -> deno_core::v8::FunctionCallback
+ where
+ SP: SomePermission + 'static,
+ {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func::<SP>.map_fn_to()
+ }
+ pub fn decl<'scope, SP>() -> deno_core::OpDecl
+ where
+ SP: SomePermission + 'static,
+ {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr::<SP>(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_foo_fast::<SP> {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 0usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ pub fn call<SP>(state: &mut OpState)
+ where
+ SP: SomePermission + 'static,
+ {}
+ pub fn v8_func<'scope, SP>(
+ scope: &mut deno_core::v8::HandleScope<'scope>,
+ args: deno_core::v8::FunctionCallbackArguments,
+ mut rv: deno_core::v8::ReturnValue,
+ )
+ where
+ SP: SomePermission + 'static,
+ {
+ 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::<SP>(&mut std::cell::RefCell::borrow_mut(&ctx.state));
+ let op_state = ::std::cell::RefCell::borrow(&*ctx.state);
+ op_state.tracker.track_sync(ctx.id);
+ }
+}
struct op_foo_fast<SP> {
_phantom: ::std::marker::PhantomData<SP>,
}
diff --git a/ops/optimizer_tests/op_state_result.out b/ops/optimizer_tests/op_state_result.out
index 5174dd7f2..76070b536 100644
--- a/ops/optimizer_tests/op_state_result.out
+++ b/ops/optimizer_tests/op_state_result.out
@@ -1,3 +1,104 @@
+#[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;
+#[doc(hidden)]
+impl foo {
+ pub fn name() -> &'static str {
+ stringify!(foo)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(foo_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 2usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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,
+ op_state.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,
+ op_state.get_error_class_fn,
+ &err,
+ );
+ scope.throw_exception(exception);
+ }
+ };
+ }
+}
struct foo_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/op_state_warning.out b/ops/optimizer_tests/op_state_warning.out
index 2c40b0f71..9917fbf79 100644
--- a/ops/optimizer_tests/op_state_warning.out
+++ b/ops/optimizer_tests/op_state_warning.out
@@ -1,3 +1,95 @@
+#[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;
+#[doc(hidden)]
+impl op_listen {
+ pub fn name() -> &'static str {
+ stringify!(op_listen)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_listen_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 0usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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,
+ op_state.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,
+ op_state.get_error_class_fn,
+ &err,
+ );
+ scope.throw_exception(exception);
+ }
+ };
+ }
+}
struct op_listen_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/op_state_with_transforms.out b/ops/optimizer_tests/op_state_with_transforms.out
index f981748be..541a4fd36 100644
--- a/ops/optimizer_tests/op_state_with_transforms.out
+++ b/ops/optimizer_tests/op_state_with_transforms.out
@@ -1,3 +1,110 @@
+#[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;
+#[doc(hidden)]
+impl op_now {
+ pub fn name() -> &'static str {
+ stringify!(op_now)
+ }
+ pub fn v8_fn_ptr<'scope, TP>() -> deno_core::v8::FunctionCallback
+ where
+ TP: TimersPermission + 'static,
+ {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func::<TP>.map_fn_to()
+ }
+ pub fn decl<'scope, TP>() -> deno_core::OpDecl
+ where
+ TP: TimersPermission + 'static,
+ {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr::<TP>(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_now_fast::<TP> {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 1usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ pub fn call<TP>(state: &mut OpState, buf: &mut [u8])
+ where
+ TP: TimersPermission + 'static,
+ {}
+ pub fn v8_func<'scope, TP>(
+ scope: &mut deno_core::v8::HandleScope<'scope>,
+ args: deno_core::v8::FunctionCallbackArguments,
+ mut rv: deno_core::v8::ReturnValue,
+ )
+ where
+ TP: TimersPermission + 'static,
+ {
+ 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::<
+ TP,
+ >(&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);
+ }
+}
struct op_now_fast<TP> {
_phantom: ::std::marker::PhantomData<TP>,
}
diff --git a/ops/optimizer_tests/opstate_with_arity.out b/ops/optimizer_tests/opstate_with_arity.out
index 20b7769e7..132e54aef 100644
--- a/ops/optimizer_tests/opstate_with_arity.out
+++ b/ops/optimizer_tests/opstate_with_arity.out
@@ -1,3 +1,122 @@
+#[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;
+#[doc(hidden)]
+impl op_add_4 {
+ pub fn name() -> &'static str {
+ stringify!(op_add_4)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_add_4_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 4usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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,
+ op_state.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,
+ op_state.get_error_class_fn,
+ &err,
+ );
+ scope.throw_exception(exception);
+ }
+ };
+ }
+}
struct op_add_4_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/param_mut_binding_warning.out b/ops/optimizer_tests/param_mut_binding_warning.out
new file mode 100644
index 000000000..daccc28ab
--- /dev/null
+++ b/ops/optimizer_tests/param_mut_binding_warning.out
@@ -0,0 +1,89 @@
+#[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;
+#[doc(hidden)]
+impl op_read_sync {
+ pub fn name() -> &'static str {
+ stringify!(op_read_sync)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: None,
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 2usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(
+ 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,
+ op_state.get_error_class_fn,
+ &err,
+ );
+ scope.throw_exception(exception);
+ }
+ };
+ }
+}
diff --git a/ops/optimizer_tests/raw_ptr.out b/ops/optimizer_tests/raw_ptr.out
index 30943d67d..f9f467ad9 100644
--- a/ops/optimizer_tests/raw_ptr.out
+++ b/ops/optimizer_tests/raw_ptr.out
@@ -1,3 +1,136 @@
+#[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;
+#[doc(hidden)]
+impl op_ffi_ptr_of {
+ pub fn name() -> &'static str {
+ stringify!(op_ffi_ptr_of)
+ }
+ pub fn v8_fn_ptr<'scope, FP>() -> deno_core::v8::FunctionCallback
+ where
+ FP: FfiPermissions + 'static,
+ {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func::<FP>.map_fn_to()
+ }
+ pub fn decl<'scope, FP>() -> deno_core::OpDecl
+ where
+ FP: FfiPermissions + 'static,
+ {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr::<FP>(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_ffi_ptr_of_fast::<FP> {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 2usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call<FP>(state: &mut OpState, buf: *const u8, out: &mut [u32])
+ where
+ FP: FfiPermissions + 'static,
+ {}
+ pub fn v8_func<'scope, FP>(
+ scope: &mut deno_core::v8::HandleScope<'scope>,
+ args: deno_core::v8::FunctionCallbackArguments,
+ mut rv: deno_core::v8::ReturnValue,
+ )
+ where
+ FP: FfiPermissions + 'static,
+ {
+ 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::<
+ FP,
+ >(&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);
+ }
+}
struct op_ffi_ptr_of_fast<FP> {
_phantom: ::std::marker::PhantomData<FP>,
}
diff --git a/ops/optimizer_tests/serde_v8_value.out b/ops/optimizer_tests/serde_v8_value.out
index 8c7630547..d4f2c0321 100644
--- a/ops/optimizer_tests/serde_v8_value.out
+++ b/ops/optimizer_tests/serde_v8_value.out
@@ -1,3 +1,76 @@
+#[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;
+#[doc(hidden)]
+impl op_is_proxy {
+ pub fn name() -> &'static str {
+ stringify!(op_is_proxy)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: Some(
+ Box::new(op_is_proxy_fast {
+ _phantom: ::std::marker::PhantomData,
+ }),
+ ),
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 1usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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)
+ ),
+ )
+ }
+ };
+ }
+}
struct op_is_proxy_fast {
_phantom: ::std::marker::PhantomData<()>,
}
diff --git a/ops/optimizer_tests/u64_result.out b/ops/optimizer_tests/u64_result.out
new file mode 100644
index 000000000..0039c7575
--- /dev/null
+++ b/ops/optimizer_tests/u64_result.out
@@ -0,0 +1,72 @@
+#[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;
+#[doc(hidden)]
+impl op_bench_now {
+ pub fn name() -> &'static str {
+ stringify!(op_bench_now)
+ }
+ pub fn v8_fn_ptr<'scope>() -> deno_core::v8::FunctionCallback {
+ use deno_core::v8::MapFnTo;
+ Self::v8_func.map_fn_to()
+ }
+ pub fn decl<'scope>() -> deno_core::OpDecl {
+ deno_core::OpDecl {
+ name: Self::name(),
+ v8_fn_ptr: Self::v8_fn_ptr(),
+ enabled: true,
+ fast_fn: None,
+ is_async: false,
+ is_unstable: false,
+ is_v8: false,
+ argc: 0usize,
+ }
+ }
+ #[inline]
+ #[allow(clippy::too_many_arguments)]
+ fn call(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,
+ op_state.get_error_class_fn,
+ &err,
+ );
+ scope.throw_exception(exception);
+ }
+ };
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-25 08:43:08 +0000