From 1d1eab00287296d67419d5cb390216a8f20bab77 Mon Sep 17 00:00:00 2001 From: Paho Lurie-Gregg Date: Tue, 30 Apr 2024 09:05:12 -0700 Subject: [PATCH] Make `Dynamic::try_cast_raw` public This function is useful for error-reporting. With `try_cast`, one has to do one of the following: 1. Pre-clone the `Dynamic`. 2. Check `Dynamic::is` first, and still handle the `None` case of `try_cast`. To maintain the pattern of `_raw` for internal functions, we rename it to `try_cast_result`. --- src/api/call_fn.rs | 2 +- src/api/eval.rs | 2 +- src/eval/stmt.rs | 2 +- src/func/call.rs | 19 +++++++++++-------- src/func/native.rs | 4 ++-- src/types/dynamic.rs | 4 ++-- src/types/fn_ptr.rs | 4 ++-- 7 files changed, 20 insertions(+), 17 deletions(-) diff --git a/src/api/call_fn.rs b/src/api/call_fn.rs index fd94391d4..3774be31c 100644 --- a/src/api/call_fn.rs +++ b/src/api/call_fn.rs @@ -183,7 +183,7 @@ impl Engine { options, ) .and_then(|result| { - result.try_cast_raw().map_err(|r| { + result.try_cast_result().map_err(|r| { let result_type = self.map_type_name(r.type_name()); let cast_type = match type_name::() { typ if typ.contains("::") => self.map_type_name(typ), diff --git a/src/api/eval.rs b/src/api/eval.rs index 5ce11042c..6c4654220 100644 --- a/src/api/eval.rs +++ b/src/api/eval.rs @@ -198,7 +198,7 @@ impl Engine { return Ok(reify! { result => T }); } - result.try_cast_raw::().map_err(|v| { + result.try_cast_result::().map_err(|v| { let typename = match type_name::() { typ if typ.contains("::") => self.map_type_name(typ), typ => typ, diff --git a/src/eval/stmt.rs b/src/eval/stmt.rs index 6ad04e0fd..22e42d277 100644 --- a/src/eval/stmt.rs +++ b/src/eval/stmt.rs @@ -903,7 +903,7 @@ impl Engine { let v = self.eval_expr(global, caches, scope, this_ptr, expr)?; - let path = v.try_cast_raw::().map_err(|v| { + let path = v.try_cast_result::().map_err(|v| { self.make_type_mismatch_err::( v.type_name(), expr.position(), diff --git a/src/func/call.rs b/src/func/call.rs index 5a6d693c0..3ab5fe92c 100644 --- a/src/func/call.rs +++ b/src/func/call.rs @@ -791,12 +791,15 @@ impl Engine { } // FnPtr call on object - let fn_ptr = call_args[0].take().try_cast_raw::().map_err(|v| { - self.make_type_mismatch_err::( - self.map_type_name(v.type_name()), - first_arg_pos, - ) - })?; + let fn_ptr = call_args[0] + .take() + .try_cast_result::() + .map_err(|v| { + self.make_type_mismatch_err::( + self.map_type_name(v.type_name()), + first_arg_pos, + ) + })?; #[cfg(not(feature = "no_function"))] let ( @@ -1033,7 +1036,7 @@ impl Engine { let (first_arg_value, first_arg_pos) = self.get_arg_value(global, caches, scope, this_ptr.as_deref_mut(), arg)?; - let fn_ptr = first_arg_value.try_cast_raw::().map_err(|v| { + let fn_ptr = first_arg_value.try_cast_result::().map_err(|v| { self.make_type_mismatch_err::( self.map_type_name(v.type_name()), first_arg_pos, @@ -1128,7 +1131,7 @@ impl Engine { let (first_arg_value, first_arg_pos) = self.get_arg_value(global, caches, scope, this_ptr.as_deref_mut(), first)?; - let mut fn_ptr = first_arg_value.try_cast_raw::().map_err(|v| { + let mut fn_ptr = first_arg_value.try_cast_result::().map_err(|v| { self.make_type_mismatch_err::( self.map_type_name(v.type_name()), first_arg_pos, diff --git a/src/func/native.rs b/src/func/native.rs index 365953c2d..94f128067 100644 --- a/src/func/native.rs +++ b/src/func/native.rs @@ -296,7 +296,7 @@ impl<'a> NativeCallContext<'a> { self._call_fn_raw(fn_name, args, false, false, false) .and_then(|result| { - result.try_cast_raw().map_err(|r| { + result.try_cast_result().map_err(|r| { let result_type = self.engine().map_type_name(r.type_name()); let cast_type = match type_name::() { typ if typ.contains("::") => self.engine.map_type_name(typ), @@ -329,7 +329,7 @@ impl<'a> NativeCallContext<'a> { self._call_fn_raw(fn_name, args, true, false, false) .and_then(|result| { - result.try_cast_raw().map_err(|r| { + result.try_cast_result().map_err(|r| { let result_type = self.engine().map_type_name(r.type_name()); let cast_type = match type_name::() { typ if typ.contains("::") => self.engine.map_type_name(typ), diff --git a/src/types/dynamic.rs b/src/types/dynamic.rs index dfbd1f24d..52097a380 100644 --- a/src/types/dynamic.rs +++ b/src/types/dynamic.rs @@ -1441,7 +1441,7 @@ impl Dynamic { #[must_use] #[allow(unused_mut)] pub fn try_cast(mut self) -> Option { - self.try_cast_raw().ok() + self.try_cast_result().ok() } /// Convert the [`Dynamic`] value into specific type. /// @@ -1463,7 +1463,7 @@ impl Dynamic { /// /// These normally shouldn't occur since most operations in Rhai are single-threaded. #[allow(unused_mut)] - pub(crate) fn try_cast_raw(mut self) -> Result { + pub fn try_cast_result(mut self) -> Result { // Coded this way in order to maximally leverage potentials for dead-code removal. #[cfg(not(feature = "no_closure"))] diff --git a/src/types/fn_ptr.rs b/src/types/fn_ptr.rs index 35346942b..c4795172e 100644 --- a/src/types/fn_ptr.rs +++ b/src/types/fn_ptr.rs @@ -163,7 +163,7 @@ impl FnPtr { let ctx = (engine, self.fn_name(), None, &*global, Position::NONE).into(); self.call_raw(&ctx, None, arg_values).and_then(|result| { - result.try_cast_raw().map_err(|r| { + result.try_cast_result().map_err(|r| { let result_type = engine.map_type_name(r.type_name()); let cast_type = match type_name::() { typ if typ.contains("::") => engine.map_type_name(typ), @@ -190,7 +190,7 @@ impl FnPtr { args.parse(&mut arg_values); self.call_raw(context, None, arg_values).and_then(|result| { - result.try_cast_raw().map_err(|r| { + result.try_cast_result().map_err(|r| { let result_type = context.engine().map_type_name(r.type_name()); let cast_type = match type_name::() { typ if typ.contains("::") => context.engine().map_type_name(typ),