kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Deprecate From<EvalAltResult> for Result<T, Box<EvalAltResult>> because it is clearer for code to explicitly wrap errors in Err.

Browse Source
This commit is contained in:
Stephen Chung 2021-10-19 23:52:58 +08:00
parent 6d31bb0d19
commit 3001e90775
23 changed files with 226 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CHANGELOG.md
View File

@ -7,9 +7,14 @@ Version 1.2.0
Enhancements
------------
* `NativeCallContext::call_fn_dynamic_raw` is deprecated and `NativeCallContext::call_fn_raw` is added.
* Array methods now avoid cloning as much as possible (although most predicates will involve cloning anyway if passed a closure).
* Inlining is disabled for error-path functions because, most of the time, the script fails completely when an error is encountered.
* Inlining is disabled for error-path functions because errors are exceptional and scripts usually fail completely when an error is encountered.
Deprecated API's
----------------
* `NativeCallContext::call_fn_dynamic_raw` is deprecated and `NativeCallContext::call_fn_raw` is added.
* `From<EvalAltResult>` for `Result<T, Box<EvalAltResult>>` is deprecated so it will no longer be possible to do `EvalAltResult::ErrorXXXXX.into()` to convert to a `Result`; instead, `Err(EvalAltResult:ErrorXXXXX.into())` must be used. Code is clearer if errors are explicitly wrapped in `Err`.
Version 1.1.0

4
codegen/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "rhai_codegen"
version = "1.1.0"
version = "1.1.1"
edition = "2018"
authors = ["jhwgh1968", "Stephen Chung"]
description = "Procedural macros support package for Rhai, a scripting language and engine for Rust"
@ -16,7 +16,7 @@ default = []
metadata = []
[dev-dependencies]
rhai = { path = "..", version = "1" }
rhai = { path = "..", version = "1.1" }
trybuild = "1"
[dependencies]

2
codegen/src/function.rs
View File

@ -696,7 +696,7 @@ impl ExportedFn {
unpack_statements.push(
syn::parse2::<syn::Stmt>(quote! {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant(#arg_lit_str.to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant(#arg_lit_str.to_string(), Position::NONE).into());
}
})
.unwrap(),

2
codegen/src/test/function.rs
View File

@ -486,7 +486,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<usize>();
let arg0 = &mut args[0usize].write_lock::<usize>().unwrap();

22
codegen/src/test/module.rs
View File

@ -1096,7 +1096,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg0 = &mut args[0usize].write_lock::<FLOAT>().unwrap();
Ok(Dynamic::from(increment(arg0)))
@ -1155,7 +1155,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg0 = &mut args[0usize].write_lock::<FLOAT>().unwrap();
Ok(Dynamic::from(increment(arg0)))
@ -1235,7 +1235,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg0 = &mut args[0usize].write_lock::<FLOAT>().unwrap();
Ok(Dynamic::from(increment(arg0)))
@ -1316,7 +1316,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg0 = &mut args[0usize].write_lock::<u64>().unwrap();
Ok(Dynamic::from(int_foo(arg0)))
@ -1376,7 +1376,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg0 = &mut args[0usize].write_lock::<u64>().unwrap();
Ok(Dynamic::from(int_foo(arg0)))
@ -1433,7 +1433,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<u64>();
let arg0 = &mut args[0usize].write_lock::<u64>().unwrap();
@ -1494,7 +1494,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<u64>();
let arg0 = &mut args[0usize].write_lock::<u64>().unwrap();
@ -1552,7 +1552,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<u64>();
let arg0 = &mut args[0usize].write_lock::<MyCollection>().unwrap();
@ -1613,7 +1613,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<u64>();
let arg0 = &mut args[0usize].write_lock::<MyCollection>().unwrap();
@ -1671,7 +1671,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<u64>();
let arg2 = mem::take(args[2usize]).cast::<FLOAT>();
@ -1733,7 +1733,7 @@ mod generate_tests {
#[inline(always)]
fn call(&self, context: NativeCallContext, args: &mut [&mut Dynamic]) -> RhaiResult {
if args[0usize].is_read_only() {
return EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant("x".to_string(), Position::NONE).into());
}
let arg1 = mem::take(args[1usize]).cast::<u64>();
let arg2 = mem::take(args[2usize]).cast::<FLOAT>();

9
src/deprecated.rs
View File

@ -168,3 +168,12 @@ impl NativeCallContext<'_> {
self.call_fn_raw(fn_name.as_ref(), is_method_call, is_method_call, args)
}
}
#[allow(useless_deprecated)]
#[deprecated(since = "1.2.0", note = "explicitly wrap `EvalAltResult` in `Err`")]
impl<T> From<EvalAltResult> for Result<T, Box<EvalAltResult>> {
#[inline(always)]
fn from(err: EvalAltResult) -> Self {
Err(err.into())
}
}

88
src/engine.rs
View File

@ -1221,7 +1221,7 @@ impl Engine {
return if let Some(val) = this_ptr {
Ok(((*val).into(), *pos))
} else {
EvalAltResult::ErrorUnboundThis(*pos).into()
Err(EvalAltResult::ErrorUnboundThis(*pos).into())
}
}
_ if state.always_search_scope => (0, expr.position()),
@ -1723,7 +1723,7 @@ impl Engine {
}
}
// Syntax error
_ => EvalAltResult::ErrorDotExpr("".into(), rhs.position()).into(),
_ => Err(EvalAltResult::ErrorDotExpr("".into(), rhs.position()).into()),
}
}
}
@ -1958,12 +1958,11 @@ impl Engine {
arr_len
- index
.checked_abs()
.ok_or_else(|| {
EvalAltResult::ErrorArrayBounds(arr_len, index, idx_pos).into()
})
.ok_or_else(|| EvalAltResult::ErrorArrayBounds(arr_len, index, idx_pos))
.and_then(|n| {
if n as usize > arr_len {
EvalAltResult::ErrorArrayBounds(arr_len, index, idx_pos).into()
Err(EvalAltResult::ErrorArrayBounds(arr_len, index, idx_pos)
.into())
} else {
Ok(n as usize)
}
@ -2014,7 +2013,9 @@ impl Engine {
let offset = index as usize;
(
if offset >= bits {
return EvalAltResult::ErrorBitFieldBounds(bits, index, idx_pos).into();
return Err(
EvalAltResult::ErrorBitFieldBounds(bits, index, idx_pos).into()
);
} else {
(*value & (1 << offset)) != 0
},
@ -2025,14 +2026,16 @@ impl Engine {
(
// Count from end if negative
if offset > bits {
return EvalAltResult::ErrorBitFieldBounds(bits, index, idx_pos).into();
return Err(
EvalAltResult::ErrorBitFieldBounds(bits, index, idx_pos).into()
);
} else {
(*value & (1 << (bits - offset))) != 0
},
offset,
)
} else {
return EvalAltResult::ErrorBitFieldBounds(bits, index, idx_pos).into();
return Err(EvalAltResult::ErrorBitFieldBounds(bits, index, idx_pos).into());
};
Ok(Target::BitField(target, offset, bit_value.into()))
@ -2066,7 +2069,7 @@ impl Engine {
)
} else {
let chars_len = s.chars().count();
return EvalAltResult::ErrorStringBounds(chars_len, index, idx_pos).into();
return Err(EvalAltResult::ErrorStringBounds(chars_len, index, idx_pos).into());
};
Ok(Target::StringChar(target, offset, ch.into()))
@ -2083,7 +2086,7 @@ impl Engine {
.map(|(v, _)| v.into())
}
_ => EvalAltResult::ErrorIndexingType(
_ => Err(EvalAltResult::ErrorIndexingType(
format!(
"{} [{}]",
self.map_type_name(target.type_name()),
@ -2091,7 +2094,7 @@ impl Engine {
),
Position::NONE,
)
.into(),
.into()),
}
}
@ -2386,7 +2389,9 @@ impl Engine {
) -> Result<(), Box<EvalAltResult>> {
if target.is_read_only() {
// Assignment to constant variable
return EvalAltResult::ErrorAssignmentToConstant(root.0.to_string(), root.1).into();
return Err(
EvalAltResult::ErrorAssignmentToConstant(root.0.to_string(), root.1).into(),
);
}
let mut new_val = new_val;
@ -2482,8 +2487,11 @@ impl Engine {
.expect("`lhs_ptr` is `Variable`");
if !lhs_ptr.is_ref() {
return EvalAltResult::ErrorAssignmentToConstant(var_name.to_string(), pos)
.into();
return Err(EvalAltResult::ErrorAssignmentToConstant(
var_name.to_string(),
pos,
)
.into());
}
#[cfg(not(feature = "unchecked"))]
@ -2735,11 +2743,11 @@ impl Engine {
if let Some(c) = counter_index {
#[cfg(not(feature = "unchecked"))]
if x > INT::MAX as usize {
return EvalAltResult::ErrorArithmetic(
return Err(EvalAltResult::ErrorArithmetic(
format!("for-loop counter overflow: {}", x),
counter.as_ref().expect("`counter` is `Some`").pos,
)
.into();
.into());
}
let mut counter_var = scope
@ -2789,13 +2797,13 @@ impl Engine {
scope.rewind(orig_scope_len);
Ok(Dynamic::UNIT)
} else {
EvalAltResult::ErrorFor(expr.position()).into()
Err(EvalAltResult::ErrorFor(expr.position()).into())
}
}
// Continue/Break statement
Stmt::BreakLoop(options, pos) => {
EvalAltResult::LoopBreak(options.contains(AST_OPTION_BREAK_OUT), *pos).into()
Err(EvalAltResult::LoopBreak(options.contains(AST_OPTION_BREAK_OUT), *pos).into())
}
// Namespace-qualified function call
@ -2918,29 +2926,29 @@ impl Engine {
// Throw value
Stmt::Return(options, Some(expr), pos) if options.contains(AST_OPTION_BREAK_OUT) => {
EvalAltResult::ErrorRuntime(
Err(EvalAltResult::ErrorRuntime(
self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)?
.flatten(),
*pos,
)
.into()
.into())
}
// Empty throw
Stmt::Return(options, None, pos) if options.contains(AST_OPTION_BREAK_OUT) => {
EvalAltResult::ErrorRuntime(Dynamic::UNIT, *pos).into()
Err(EvalAltResult::ErrorRuntime(Dynamic::UNIT, *pos).into())
}
// Return value
Stmt::Return(_, Some(expr), pos) => EvalAltResult::Return(
Stmt::Return(_, Some(expr), pos) => Err(EvalAltResult::Return(
self.eval_expr(scope, mods, state, lib, this_ptr, expr, level)?
.flatten(),
*pos,
)
.into(),
.into()),
// Empty return
Stmt::Return(_, None, pos) => EvalAltResult::Return(Dynamic::UNIT, *pos).into(),
Stmt::Return(_, None, pos) => Err(EvalAltResult::Return(Dynamic::UNIT, *pos).into()),
// Let/const statement
Stmt::Var(expr, x, options, _) => {
@ -3003,7 +3011,7 @@ impl Engine {
// Guard against too many modules
#[cfg(not(feature = "unchecked"))]
if state.num_modules >= self.max_modules() {
return EvalAltResult::ErrorTooManyModules(*_pos).into();
return Err(EvalAltResult::ErrorTooManyModules(*_pos).into());
}
if let Some(path) = self
@ -3032,7 +3040,10 @@ impl Engine {
.map(|r| r.resolve(self, source, &path, path_pos))
})
.unwrap_or_else(|| {
EvalAltResult::ErrorModuleNotFound(path.to_string(), path_pos).into()
Err(
EvalAltResult::ErrorModuleNotFound(path.to_string(), path_pos)
.into(),
)
})?;
if let Some(name) = export.as_ref().map(|x| x.name.clone()) {
@ -3065,7 +3076,9 @@ impl Engine {
if rename.is_empty() { name } else { rename }.clone(),
);
} else {
return EvalAltResult::ErrorVariableNotFound(name.to_string(), *pos).into();
return Err(
EvalAltResult::ErrorVariableNotFound(name.to_string(), *pos).into()
);
}
}
Ok(Dynamic::UNIT)
@ -3182,11 +3195,11 @@ impl Engine {
.max_string_size
.map_or(usize::MAX, NonZeroUsize::get)
{
return EvalAltResult::ErrorDataTooLarge(
return Err(EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
Position::NONE,
)
.into();
.into());
}
#[cfg(not(feature = "no_index"))]
@ -3196,8 +3209,11 @@ impl Engine {
.max_array_size
.map_or(usize::MAX, NonZeroUsize::get)
{
return EvalAltResult::ErrorDataTooLarge("Size of array".to_string(), Position::NONE)
.into();
return Err(EvalAltResult::ErrorDataTooLarge(
"Size of array".to_string(),
Position::NONE,
)
.into());
}
#[cfg(not(feature = "no_object"))]
@ -3207,11 +3223,11 @@ impl Engine {
.max_map_size
.map_or(usize::MAX, NonZeroUsize::get)
{
return EvalAltResult::ErrorDataTooLarge(
return Err(EvalAltResult::ErrorDataTooLarge(
"Size of object map".to_string(),
Position::NONE,
)
.into();
.into());
}
Ok(())
@ -3228,14 +3244,14 @@ impl Engine {
// Guard against too many operations
if self.max_operations() > 0 && state.num_operations > self.max_operations() {
return EvalAltResult::ErrorTooManyOperations(pos).into();
return Err(EvalAltResult::ErrorTooManyOperations(pos).into());
}
// Report progress - only in steps
if let Some(ref progress) = self.progress {
if let Some(token) = progress(state.num_operations) {
// Terminate script if progress returns a termination token
return EvalAltResult::ErrorTerminated(token, pos).into();
return Err(EvalAltResult::ErrorTerminated(token, pos).into());
}
}

7
src/error.rs
View File

@ -453,10 +453,3 @@ impl EvalAltResult {
self
}
}
impl<T> From<EvalAltResult> for Result<T, Box<EvalAltResult>> {
#[inline(always)]
fn from(err: EvalAltResult) -> Self {
Err(err.into())
}
}

43
src/fn_call.rs
View File

@ -115,11 +115,11 @@ pub fn ensure_no_data_race(
.skip(if is_method_call { 1 } else { 0 })
.find(|(_, a)| a.is_locked())
{
return EvalAltResult::ErrorDataRace(
return Err(EvalAltResult::ErrorDataRace(
format!("argument #{} of function '{}'", n + 1, fn_name),
Position::NONE,
)
.into();
.into());
}
Ok(())
@ -392,7 +392,7 @@ impl Engine {
crate::engine::FN_IDX_GET => {
assert!(args.len() == 2);
EvalAltResult::ErrorIndexingType(
Err(EvalAltResult::ErrorIndexingType(
format!(
"{} [{}]",
self.map_type_name(args[0].type_name()),
@ -400,7 +400,7 @@ impl Engine {
),
pos,
)
.into()
.into())
}
// index setter function not found?
@ -408,7 +408,7 @@ impl Engine {
crate::engine::FN_IDX_SET => {
assert!(args.len() == 3);
EvalAltResult::ErrorIndexingType(
Err(EvalAltResult::ErrorIndexingType(
format!(
"{} [{}] = {}",
self.map_type_name(args[0].type_name()),
@ -417,7 +417,7 @@ impl Engine {
),
pos,
)
.into()
.into())
}
// Getter function not found?
@ -425,7 +425,7 @@ impl Engine {
_ if name.starts_with(crate::engine::FN_GET) => {
assert!(args.len() == 1);
EvalAltResult::ErrorDotExpr(
Err(EvalAltResult::ErrorDotExpr(
format!(
"Unknown property '{}' - a getter is not registered for type '{}'",
&name[crate::engine::FN_GET.len()..],
@ -433,7 +433,7 @@ impl Engine {
),
pos,
)
.into()
.into())
}
// Setter function not found?
@ -441,7 +441,7 @@ impl Engine {
_ if name.starts_with(crate::engine::FN_SET) => {
assert!(args.len() == 2);
EvalAltResult::ErrorDotExpr(
Err(EvalAltResult::ErrorDotExpr(
format!(
"No writable property '{}' - a setter is not registered for type '{}' to handle '{}'",
&name[crate::engine::FN_SET.len()..],
@ -450,14 +450,15 @@ impl Engine {
),
pos,
)
.into()
.into())
}
// Raise error
_ => {
EvalAltResult::ErrorFunctionNotFound(self.gen_call_signature(None, name, args), pos)
.into()
}
_ => Err(EvalAltResult::ErrorFunctionNotFound(
self.gen_call_signature(None, name, args),
pos,
)
.into()),
}
}
@ -489,7 +490,7 @@ impl Engine {
err: Box<EvalAltResult>,
pos: Position,
) -> RhaiResult {
EvalAltResult::ErrorInFunctionCall(
Err(EvalAltResult::ErrorInFunctionCall(
name,
fn_def
.lib
@ -500,7 +501,7 @@ impl Engine {
err,
pos,
)
.into()
.into())
}
#[cfg(not(feature = "unchecked"))]
@ -514,7 +515,7 @@ impl Engine {
#[cfg(not(feature = "no_function"))]
#[cfg(not(feature = "unchecked"))]
if level > self.max_call_levels() {
return EvalAltResult::ErrorStackOverflow(pos).into();
return Err(EvalAltResult::ErrorStackOverflow(pos).into());
}
let orig_scope_level = state.scope_level;
@ -578,7 +579,7 @@ impl Engine {
// System errors are passed straight-through
mut err if err.is_system_exception() => {
err.set_position(pos);
err.into()
Err(err.into())
}
// Other errors are wrapped in `ErrorInFunctionCall`
_ => make_error(fn_def.name.to_string(), fn_def, state, err, pos),
@ -651,7 +652,7 @@ impl Engine {
) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
fn no_method_err(name: &str, pos: Position) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
let msg = format!("'{0}' should not be called this way. Try {0}(...);", name);
EvalAltResult::ErrorRuntime(msg.into(), pos).into()
Err(EvalAltResult::ErrorRuntime(msg.into(), pos).into())
}
// Check for data race.
@ -1458,11 +1459,11 @@ impl Engine {
Some(f) => unreachable!("unknown function type: {:?}", f),
None => EvalAltResult::ErrorFunctionNotFound(
None => Err(EvalAltResult::ErrorFunctionNotFound(
self.gen_call_signature(Some(namespace), fn_name, &args),
pos,
)
.into(),
.into()),
}
}
}

6
src/fn_native.rs
View File

@ -183,6 +183,9 @@ impl<'a> NativeCallContext<'a> {
}
/// Call a function inside the call context.
///
/// If `is_method_call` is [`true`], the first argument is assumed to be the
/// `this` pointer for a script-defined function (or the object of a method call).
///
/// # WARNING
///
/// All arguments may be _consumed_, meaning that they may be replaced by `()`.
@ -193,9 +196,6 @@ impl<'a> NativeCallContext<'a> {
///
/// If `is_ref_mut` is [`true`], the first argument is assumed to be passed
/// by reference and is not consumed.
///
/// If `is_method_call` is [`true`], the first argument is assumed to be the
/// `this` pointer for a script-defined function (or the object of a method call).
pub fn call_fn_raw(
&self,
fn_name: &str,

2
src/fn_ptr.rs
View File

@ -148,7 +148,7 @@ impl TryFrom<Identifier> for FnPtr {
if is_valid_identifier(value.chars()) {
Ok(Self(value, Default::default()))
} else {
EvalAltResult::ErrorFunctionNotFound(value.to_string(), Position::NONE).into()
Err(EvalAltResult::ErrorFunctionNotFound(value.to_string(), Position::NONE).into())
}
}
}

8
src/fn_register.rs
View File

@ -123,7 +123,7 @@ macro_rules! def_register {
#[inline(always)] fn into_callable_function(self) -> CallableFunction {
CallableFunction::$abi(Box::new(move |ctx: NativeCallContext, args: &mut FnCallArgs| {
if args.len() == 2 && args[0].is_read_only() && is_setter(ctx.fn_name()) {
return EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into());
}
// The arguments are assumed to be of the correct number and types!
@ -151,7 +151,7 @@ macro_rules! def_register {
#[inline(always)] fn into_callable_function(self) -> CallableFunction {
CallableFunction::$abi(Box::new(move |ctx: NativeCallContext, args: &mut FnCallArgs| {
if args.len() == 2 && args[0].is_read_only() && is_setter(ctx.fn_name()) {
return EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into());
}
// The arguments are assumed to be of the correct number and types!
@ -179,7 +179,7 @@ macro_rules! def_register {
#[inline(always)] fn into_callable_function(self) -> CallableFunction {
CallableFunction::$abi(Box::new(move |ctx: NativeCallContext, args: &mut FnCallArgs| {
if args.len() == 2 && args[0].is_read_only() && is_setter(ctx.fn_name()) {
return EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into());
}
// The arguments are assumed to be of the correct number and types!
@ -204,7 +204,7 @@ macro_rules! def_register {
#[inline(always)] fn into_callable_function(self) -> CallableFunction {
CallableFunction::$abi(Box::new(move |ctx: NativeCallContext, args: &mut FnCallArgs| {
if args.len() == 2 && args[0].is_read_only() && is_setter(ctx.fn_name()) {
return EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into();
return Err(EvalAltResult::ErrorAssignmentToConstant(Default::default(), Position::NONE).into());
}
// The arguments are assumed to be of the correct number and types!

2
src/module/resolvers/collection.rs
View File

@ -136,7 +136,7 @@ impl ModuleResolver for ModuleResolversCollection {
}
}
EvalAltResult::ErrorModuleNotFound(path.into(), pos).into()
Err(EvalAltResult::ErrorModuleNotFound(path.into(), pos).into())
}
}

2
src/module/resolvers/dummy.rs
View File

@ -45,6 +45,6 @@ impl ModuleResolver for DummyModuleResolver {
path: &str,
pos: Position,
) -> Result<Shared<Module>, Box<EvalAltResult>> {
EvalAltResult::ErrorModuleNotFound(path.into(), pos).into()
Err(EvalAltResult::ErrorModuleNotFound(path.into(), pos).into())
}
}

47
src/packages/array_basic.rs
View File

@ -79,8 +79,11 @@ mod array_functions {
// Check if array will be over max size limit
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_array_size() > 0 && (len as usize) > _ctx.engine().max_array_size() {
return EvalAltResult::ErrorDataTooLarge("Size of array".to_string(), Position::NONE)
.into();
return Err(EvalAltResult::ErrorDataTooLarge(
"Size of array".to_string(),
Position::NONE,
)
.into());
}
if len as usize > array.len() {
@ -267,13 +270,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall(
"map".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
},
@ -309,13 +312,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall(
"filter".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
}
@ -473,13 +476,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall(
"index_of".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
}
@ -519,13 +522,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall(
"some".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
}
@ -565,13 +568,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall(
"all".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
}
@ -781,13 +784,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
return Err(EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
}
@ -875,13 +878,13 @@ mod array_functions {
ctx.call_fn_raw(fn_name, true, false, &mut args)?
}
_ => {
return EvalAltResult::ErrorInFunctionCall(
"drain".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall(
"retain".to_string(),
ctx.source().unwrap_or("").to_string(),
err,
Position::NONE,
)
.into()
.into())
}
},
}

30
src/packages/iter_basic.rs
View File

@ -25,7 +25,7 @@ where
#[cfg(not(feature = "unchecked"))]
if let Some(r) = from.checked_add(&step) {
if r == from {
return EvalAltResult::ErrorInFunctionCall(
return Err(EvalAltResult::ErrorInFunctionCall(
"range".to_string(),
Default::default(),
EvalAltResult::ErrorArithmetic(
@ -35,7 +35,7 @@ where
.into(),
crate::Position::NONE,
)
.into();
.into());
}
}
@ -122,21 +122,27 @@ impl BitRange {
#[cfg(not(feature = "unchecked"))]
if offset >= BITS {
return EvalAltResult::ErrorBitFieldBounds(BITS, from, crate::Position::NONE)
.into();
return Err(
EvalAltResult::ErrorBitFieldBounds(BITS, from, crate::Position::NONE).into(),
);
}
offset
} else {
#[cfg(not(feature = "unchecked"))]
if let Some(abs_from) = from.checked_abs() {
if (abs_from as usize) > BITS {
return EvalAltResult::ErrorBitFieldBounds(BITS, from, crate::Position::NONE)
.into();
return Err(EvalAltResult::ErrorBitFieldBounds(
BITS,
from,
crate::Position::NONE,
)
.into());
}
BITS - (abs_from as usize)
} else {
return EvalAltResult::ErrorBitFieldBounds(BITS, from, crate::Position::NONE)
.into();
return Err(
EvalAltResult::ErrorBitFieldBounds(BITS, from, crate::Position::NONE).into(),
);
}
#[cfg(feature = "unchecked")]
@ -325,10 +331,10 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, {
pub fn new(from: FLOAT, to: FLOAT, step: FLOAT) -> Result<Self, Box<EvalAltResult>> {
#[cfg(not(feature = "unchecked"))]
if step == 0.0 {
return EvalAltResult::ErrorInFunctionCall("range".to_string(), "".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall("range".to_string(), "".to_string(),
EvalAltResult::ErrorArithmetic("step value cannot be zero".to_string(), crate::Position::NONE).into(),
crate::Position::NONE,
).into();
).into());
}
Ok(Self(from, to, step))
@ -387,10 +393,10 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, {
pub fn new(from: Decimal, to: Decimal, step: Decimal) -> Result<Self, Box<EvalAltResult>> {
#[cfg(not(feature = "unchecked"))]
if step.is_zero() {
return EvalAltResult::ErrorInFunctionCall("range".to_string(), "".to_string(),
return Err(EvalAltResult::ErrorInFunctionCall("range".to_string(), "".to_string(),
EvalAltResult::ErrorArithmetic("step value cannot be zero".to_string(), crate::Position::NONE).into(),
crate::Position::NONE,
).into();
).into());
}
Ok(Self(from, to, step))

8
src/packages/lang_core.rs
View File

@ -14,7 +14,7 @@ mod core_functions {
#[rhai_fn(name = "set_tag", set = "tag", return_raw)]
pub fn set_tag(value: &mut Dynamic, tag: INT) -> Result<(), Box<EvalAltResult>> {
if tag < Tag::MIN as INT {
EvalAltResult::ErrorArithmetic(
Err(EvalAltResult::ErrorArithmetic(
format!(
"{} is too small to fit into a tag (must be between {} and {})",
tag,
@ -23,9 +23,9 @@ mod core_functions {
),
Position::NONE,
)
.into()
.into())
} else if tag > Tag::MAX as INT {
EvalAltResult::ErrorArithmetic(
Err(EvalAltResult::ErrorArithmetic(
format!(
"{} is too large to fit into a tag (must be between {} and {})",
tag,
@ -34,7 +34,7 @@ mod core_functions {
),
Position::NONE,
)
.into()
.into())
} else {
value.set_tag(tag as Tag);
Ok(())

24
src/packages/logic.rs
View File

@ -202,7 +202,7 @@ mod bit_field_functions {
let offset = index as usize;
if offset >= BITS {
EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into()
Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into())
} else {
Ok((value & (1 << offset)) != 0)
}
@ -211,12 +211,12 @@ mod bit_field_functions {
// Count from end if negative
if offset > BITS {
EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into()
Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into())
} else {
Ok((value & (1 << (BITS - offset))) != 0)
}
} else {
EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into()
Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into())
}
}
#[rhai_fn(return_raw)]
@ -225,7 +225,7 @@ mod bit_field_functions {
let offset = index as usize;
if offset >= BITS {
EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into()
Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into())
} else {
let mask = 1 << offset;
if new_value {
@ -240,7 +240,7 @@ mod bit_field_functions {
// Count from end if negative
if offset > BITS {
EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into()
Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into())
} else {
let mask = 1 << offset;
if new_value {
@ -251,7 +251,7 @@ mod bit_field_functions {
Ok(())
}
} else {
EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into()
Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into())
}
}
#[rhai_fn(return_raw)]
@ -264,7 +264,7 @@ mod bit_field_functions {
let offset = index as usize;
if offset >= BITS {
return EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into();
return Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into());
}
offset
@ -273,11 +273,11 @@ mod bit_field_functions {
// Count from end if negative
if offset > BITS {
return EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into();
return Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into());
}
BITS - offset
} else {
return EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into();
return Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into());
};
let bits = if offset + bits as usize > BITS {
@ -311,7 +311,7 @@ mod bit_field_functions {
let offset = index as usize;
if offset >= BITS {
return EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into();
return Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into());
}
offset
@ -320,11 +320,11 @@ mod bit_field_functions {
// Count from end if negative
if offset > BITS {
return EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into();
return Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into());
}
BITS - offset
} else {
return EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into();
return Err(EvalAltResult::ErrorBitFieldBounds(BITS, index, Position::NONE).into());
};
let bits = if offset + bits as usize > BITS {

12
src/packages/math_basic.rs
View File

@ -114,11 +114,11 @@ mod int_functions {
#[rhai_fn(name = "parse_int", return_raw)]
pub fn parse_int_radix(string: &str, radix: INT) -> Result<INT, Box<EvalAltResult>> {
if !(2..=36).contains(&radix) {
return EvalAltResult::ErrorArithmetic(
return Err(EvalAltResult::ErrorArithmetic(
format!("Invalid radix: '{}'", radix),
Position::NONE,
)
.into();
.into());
}
INT::from_str_radix(string.trim(), radix as u32).map_err(|err| {
@ -261,11 +261,11 @@ mod float_functions {
#[rhai_fn(name = "to_int", return_raw)]
pub fn f32_to_int(x: f32) -> Result<INT, Box<EvalAltResult>> {
if cfg!(not(feature = "unchecked")) && x > (MAX_INT as f32) {
EvalAltResult::ErrorArithmetic(
Err(EvalAltResult::ErrorArithmetic(
format!("Integer overflow: to_int({})", x),
Position::NONE,
)
.into()
.into())
} else {
Ok(x.trunc() as INT)
}
@ -273,11 +273,11 @@ mod float_functions {
#[rhai_fn(name = "to_int", return_raw)]
pub fn f64_to_int(x: f64) -> Result<INT, Box<EvalAltResult>> {
if cfg!(not(feature = "unchecked")) && x > (MAX_INT as f64) {
EvalAltResult::ErrorArithmetic(
Err(EvalAltResult::ErrorArithmetic(
format!("Integer overflow: to_int({})", x),
Position::NONE,
)
.into()
.into())
} else {
Ok(x.trunc() as INT)
}

16
src/packages/string_more.rs
View File

@ -471,11 +471,11 @@ mod string_functions {
// Check if string will be over max size limit
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0 && len as usize > _ctx.engine().max_string_size() {
return crate::EvalAltResult::ErrorDataTooLarge(
return Err(crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
.into());
}
let orig_len = string.chars().count();
@ -490,11 +490,11 @@ mod string_functions {
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0 && string.len() > _ctx.engine().max_string_size()
{
return crate::EvalAltResult::ErrorDataTooLarge(
return Err(crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
.into());
}
}
@ -516,11 +516,11 @@ mod string_functions {
// Check if string will be over max size limit
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0 && len as usize > _ctx.engine().max_string_size() {
return crate::EvalAltResult::ErrorDataTooLarge(
return Err(crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
.into());
}
let mut str_len = string.chars().count();
@ -542,11 +542,11 @@ mod string_functions {
#[cfg(not(feature = "unchecked"))]
if _ctx.engine().max_string_size() > 0 && string.len() > _ctx.engine().max_string_size()
{
return crate::EvalAltResult::ErrorDataTooLarge(
return Err(crate::EvalAltResult::ErrorDataTooLarge(
"Length of string".to_string(),
crate::Position::NONE,
)
.into();
.into());
}
}

4
src/serde/de.rs
View File

@ -38,12 +38,12 @@ impl<'de> DynamicDeserializer<'de> {
}
/// Shortcut for a type conversion error.
fn type_error_str<T>(&self, error: &str) -> Result<T, Box<EvalAltResult>> {
EvalAltResult::ErrorMismatchOutputType(
Err(EvalAltResult::ErrorMismatchOutputType(
error.into(),
self.value.type_name().into(),
Position::NONE,
)
.into()
.into())
}
fn deserialize_int<V: Visitor<'de>>(
&mut self,

68
src/serde/ser.rs
View File

@ -313,24 +313,24 @@ impl Serializer for &mut DynamicSerializer {
make_variant(_variant, content)
}
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Box<EvalAltResult>> {
#[cfg(not(feature = "no_index"))]
return Ok(DynamicSerializer::new(Array::new().into()));
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"arrays are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Box<EvalAltResult>> {
@ -359,24 +359,24 @@ impl Serializer for &mut DynamicSerializer {
array: Array::with_capacity(_len),
});
#[cfg(any(feature = "no_object", feature = "no_index"))]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"tuples are not supported with 'no_index' or 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Box<EvalAltResult>> {
#[cfg(not(feature = "no_object"))]
return Ok(DynamicSerializer::new(Map::new().into()));
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn serialize_struct(
@ -400,12 +400,12 @@ impl Serializer for &mut DynamicSerializer {
map: Default::default(),
});
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
}
@ -425,12 +425,12 @@ impl SerializeSeq for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"arrays are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
// Close the sequence.
@ -438,12 +438,12 @@ impl SerializeSeq for DynamicSerializer {
#[cfg(not(feature = "no_index"))]
return Ok(self._value);
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"arrays are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
}
@ -463,24 +463,24 @@ impl SerializeTuple for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"tuples are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
fn end(self) -> Result<Self::Ok, Box<EvalAltResult>> {
#[cfg(not(feature = "no_index"))]
return Ok(self._value);
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"tuples are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
}
@ -500,24 +500,24 @@ impl SerializeTupleStruct for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"tuples are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
fn end(self) -> Result<Self::Ok, Box<EvalAltResult>> {
#[cfg(not(feature = "no_index"))]
return Ok(self._value);
#[cfg(feature = "no_index")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"tuples are not supported with 'no_index'".into(),
Position::NONE,
)
.into();
.into());
}
}
@ -532,12 +532,12 @@ impl SerializeMap for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn serialize_value<T: ?Sized + Serialize>(
@ -561,12 +561,12 @@ impl SerializeMap for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn serialize_entry<K: ?Sized + Serialize, T: ?Sized + Serialize>(
@ -586,24 +586,24 @@ impl SerializeMap for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn end(self) -> Result<Self::Ok, Box<EvalAltResult>> {
#[cfg(not(feature = "no_object"))]
return Ok(self._value);
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
}
@ -624,24 +624,24 @@ impl SerializeStruct for DynamicSerializer {
Ok(())
}
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
fn end(self) -> Result<Self::Ok, Box<EvalAltResult>> {
#[cfg(not(feature = "no_object"))]
return Ok(self._value);
#[cfg(feature = "no_object")]
return EvalAltResult::ErrorMismatchDataType(
return Err(EvalAltResult::ErrorMismatchDataType(
"".into(),
"object maps are not supported with 'no_object'".into(),
Position::NONE,
)
.into();
.into());
}
}

4
src/serde/str.rs
View File

@ -19,12 +19,12 @@ impl<'a> StringSliceDeserializer<'a> {
}
/// Shortcut for a type conversion error.
fn type_error<T>(&self) -> Result<T, Box<EvalAltResult>> {
EvalAltResult::ErrorMismatchOutputType(
Err(EvalAltResult::ErrorMismatchOutputType(
type_name::<T>().into(),
"string".into(),
Position::NONE,
)
.into()
.into())
}
}