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

Code style refinements.

Browse Source
This commit is contained in:
Stephen Chung 2021-05-29 18:33:29 +08:00
parent 5f36f1a28c
commit 76bd48d0a6
12 changed files with 157 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -1,6 +1,10 @@
Rhai Release Notes
==================
Version 0.20.3
==============
Version 0.20.2
==============

136
src/dynamic.rs
View File

@ -711,6 +711,8 @@ impl fmt::Debug for Dynamic {
}
}
use AccessMode::*;
impl Clone for Dynamic {
/// Clone the [`Dynamic`] value.
///
@ -719,33 +721,25 @@ impl Clone for Dynamic {
/// The cloned copy is marked read-write even if the original is read-only.
fn clone(&self) -> Self {
match self.0 {
Union::Unit(value, tag, _) => Self(Union::Unit(value, tag, AccessMode::ReadWrite)),
Union::Bool(value, tag, _) => Self(Union::Bool(value, tag, AccessMode::ReadWrite)),
Union::Str(ref value, tag, _) => {
Self(Union::Str(value.clone(), tag, AccessMode::ReadWrite))
}
Union::Char(value, tag, _) => Self(Union::Char(value, tag, AccessMode::ReadWrite)),
Union::Int(value, tag, _) => Self(Union::Int(value, tag, AccessMode::ReadWrite)),
Union::Unit(value, tag, _) => Self(Union::Unit(value, tag, ReadWrite)),
Union::Bool(value, tag, _) => Self(Union::Bool(value, tag, ReadWrite)),
Union::Str(ref value, tag, _) => Self(Union::Str(value.clone(), tag, ReadWrite)),
Union::Char(value, tag, _) => Self(Union::Char(value, tag, ReadWrite)),
Union::Int(value, tag, _) => Self(Union::Int(value, tag, ReadWrite)),
#[cfg(not(feature = "no_float"))]
Union::Float(value, tag, _) => Self(Union::Float(value, tag, AccessMode::ReadWrite)),
Union::Float(value, tag, _) => Self(Union::Float(value, tag, ReadWrite)),
#[cfg(feature = "decimal")]
Union::Decimal(ref value, tag, _) => {
Self(Union::Decimal(value.clone(), tag, AccessMode::ReadWrite))
Self(Union::Decimal(value.clone(), tag, ReadWrite))
}
#[cfg(not(feature = "no_index"))]
Union::Array(ref value, tag, _) => {
Self(Union::Array(value.clone(), tag, AccessMode::ReadWrite))
}
Union::Array(ref value, tag, _) => Self(Union::Array(value.clone(), tag, ReadWrite)),
#[cfg(not(feature = "no_object"))]
Union::Map(ref value, tag, _) => {
Self(Union::Map(value.clone(), tag, AccessMode::ReadWrite))
}
Union::FnPtr(ref value, tag, _) => {
Self(Union::FnPtr(value.clone(), tag, AccessMode::ReadWrite))
}
Union::Map(ref value, tag, _) => Self(Union::Map(value.clone(), tag, ReadWrite)),
Union::FnPtr(ref value, tag, _) => Self(Union::FnPtr(value.clone(), tag, ReadWrite)),
#[cfg(not(feature = "no_std"))]
Union::TimeStamp(ref value, tag, _) => {
Self(Union::TimeStamp(value.clone(), tag, AccessMode::ReadWrite))
Self(Union::TimeStamp(value.clone(), tag, ReadWrite))
}
Union::Variant(ref value, tag, _) => {
@ -755,9 +749,7 @@ impl Clone for Dynamic {
}
#[cfg(not(feature = "no_closure"))]
Union::Shared(ref cell, tag, _) => {
Self(Union::Shared(cell.clone(), tag, AccessMode::ReadWrite))
}
Union::Shared(ref cell, tag, _) => Self(Union::Shared(cell.clone(), tag, ReadWrite)),
}
}
}
@ -771,21 +763,21 @@ impl Default for Dynamic {
impl Dynamic {
/// A [`Dynamic`] containing a `()`.
pub const UNIT: Dynamic = Self(Union::Unit((), DEFAULT_TAG, AccessMode::ReadWrite));
pub const UNIT: Dynamic = Self(Union::Unit((), DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing a `true`.
pub const TRUE: Dynamic = Self(Union::Bool(true, DEFAULT_TAG, AccessMode::ReadWrite));
pub const TRUE: Dynamic = Self(Union::Bool(true, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing a [`false`].
pub const FALSE: Dynamic = Self(Union::Bool(false, DEFAULT_TAG, AccessMode::ReadWrite));
pub const FALSE: Dynamic = Self(Union::Bool(false, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing the integer zero.
pub const ZERO: Dynamic = Self(Union::Int(0, DEFAULT_TAG, AccessMode::ReadWrite));
pub const ZERO: Dynamic = Self(Union::Int(0, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing the integer one.
pub const ONE: Dynamic = Self(Union::Int(1, DEFAULT_TAG, AccessMode::ReadWrite));
pub const ONE: Dynamic = Self(Union::Int(1, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing the integer two.
pub const TWO: Dynamic = Self(Union::Int(2, DEFAULT_TAG, AccessMode::ReadWrite));
pub const TWO: Dynamic = Self(Union::Int(2, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing the integer ten.
pub const TEN: Dynamic = Self(Union::Int(10, DEFAULT_TAG, AccessMode::ReadWrite));
pub const TEN: Dynamic = Self(Union::Int(10, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing the integer negative one.
pub const NEGATIVE_ONE: Dynamic = Self(Union::Int(-1, DEFAULT_TAG, AccessMode::ReadWrite));
pub const NEGATIVE_ONE: Dynamic = Self(Union::Int(-1, DEFAULT_TAG, ReadWrite));
/// A [`Dynamic`] containing `0.0`.
///
/// Not available under `no_float`.
@ -793,7 +785,7 @@ impl Dynamic {
pub const FLOAT_ZERO: Dynamic = Self(Union::Float(
FloatWrapper::const_new(0.0),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
));
/// A [`Dynamic`] containing `1.0`.
///
@ -802,7 +794,7 @@ impl Dynamic {
pub const FLOAT_ONE: Dynamic = Self(Union::Float(
FloatWrapper::const_new(1.0),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
));
/// A [`Dynamic`] containing `2.0`.
///
@ -811,7 +803,7 @@ impl Dynamic {
pub const FLOAT_TWO: Dynamic = Self(Union::Float(
FloatWrapper::const_new(2.0),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
));
/// A [`Dynamic`] containing `10.0`.
///
@ -820,7 +812,7 @@ impl Dynamic {
pub const FLOAT_TEN: Dynamic = Self(Union::Float(
FloatWrapper::const_new(10.0),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
));
/// A [`Dynamic`] containing the `-1.0`.
///
@ -829,7 +821,7 @@ impl Dynamic {
pub const FLOAT_NEGATIVE_ONE: Dynamic = Self(Union::Float(
FloatWrapper::const_new(-1.0),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
));
/// Get the [`AccessMode`] for this [`Dynamic`].
@ -898,7 +890,7 @@ impl Dynamic {
pub fn is_read_only(&self) -> bool {
#[cfg(not(feature = "no_closure"))]
match self.0 {
Union::Shared(_, _, AccessMode::ReadOnly) => return true,
Union::Shared(_, _, ReadOnly) => return true,
Union::Shared(ref cell, _, _) => {
#[cfg(not(feature = "sync"))]
let value = cell.borrow();
@ -906,16 +898,16 @@ impl Dynamic {
let value = cell.read().unwrap();
return match value.access_mode() {
AccessMode::ReadWrite => false,
AccessMode::ReadOnly => true,
ReadWrite => false,
ReadOnly => true,
};
}
_ => (),
}
match self.access_mode() {
AccessMode::ReadWrite => false,
AccessMode::ReadOnly => true,
ReadWrite => false,
ReadOnly => true,
}
}
/// Can this [`Dynamic`] be hashed?
@ -1066,7 +1058,7 @@ impl Dynamic {
Self(Union::Variant(
Box::new(Box::new(value)),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
/// Turn the [`Dynamic`] value into a shared [`Dynamic`] value backed by an
@ -1788,37 +1780,33 @@ impl Dynamic {
impl From<()> for Dynamic {
#[inline(always)]
fn from(value: ()) -> Self {
Self(Union::Unit(value, DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::Unit(value, DEFAULT_TAG, ReadWrite))
}
}
impl From<bool> for Dynamic {
#[inline(always)]
fn from(value: bool) -> Self {
Self(Union::Bool(value, DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::Bool(value, DEFAULT_TAG, ReadWrite))
}
}
impl From<INT> for Dynamic {
#[inline(always)]
fn from(value: INT) -> Self {
Self(Union::Int(value, DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::Int(value, DEFAULT_TAG, ReadWrite))
}
}
#[cfg(not(feature = "no_float"))]
impl From<FLOAT> for Dynamic {
#[inline(always)]
fn from(value: FLOAT) -> Self {
Self(Union::Float(
value.into(),
DEFAULT_TAG,
AccessMode::ReadWrite,
))
Self(Union::Float(value.into(), DEFAULT_TAG, ReadWrite))
}
}
#[cfg(not(feature = "no_float"))]
impl From<FloatWrapper<FLOAT>> for Dynamic {
#[inline(always)]
fn from(value: FloatWrapper<FLOAT>) -> Self {
Self(Union::Float(value, DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::Float(value, DEFAULT_TAG, ReadWrite))
}
}
#[cfg(feature = "decimal")]
@ -1828,20 +1816,20 @@ impl From<Decimal> for Dynamic {
Self(Union::Decimal(
Box::new(value.into()),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
}
impl From<char> for Dynamic {
#[inline(always)]
fn from(value: char) -> Self {
Self(Union::Char(value, DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::Char(value, DEFAULT_TAG, ReadWrite))
}
}
impl<S: Into<ImmutableString>> From<S> for Dynamic {
#[inline(always)]
fn from(value: S) -> Self {
Self(Union::Str(value.into(), DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::Str(value.into(), DEFAULT_TAG, ReadWrite))
}
}
impl From<&ImmutableString> for Dynamic {
@ -1862,11 +1850,7 @@ impl Dynamic {
/// Create a [`Dynamic`] from an [`Array`].
#[inline(always)]
pub(crate) fn from_array(array: Array) -> Self {
Self(Union::Array(
Box::new(array),
DEFAULT_TAG,
AccessMode::ReadWrite,
))
Self(Union::Array(Box::new(array), DEFAULT_TAG, ReadWrite))
}
}
#[cfg(not(feature = "no_index"))]
@ -1876,7 +1860,7 @@ impl<T: Variant + Clone> From<Vec<T>> for Dynamic {
Self(Union::Array(
Box::new(value.into_iter().map(Dynamic::from).collect()),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
}
@ -1887,7 +1871,7 @@ impl<T: Variant + Clone> From<&[T]> for Dynamic {
Self(Union::Array(
Box::new(value.iter().cloned().map(Dynamic::from).collect()),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
}
@ -1898,7 +1882,7 @@ impl<T: Variant + Clone> std::iter::FromIterator<T> for Dynamic {
Self(Union::Array(
Box::new(iter.into_iter().map(Dynamic::from).collect()),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
}
@ -1907,11 +1891,7 @@ impl Dynamic {
/// Create a [`Dynamic`] from a [`Map`].
#[inline(always)]
pub(crate) fn from_map(map: Map) -> Self {
Self(Union::Map(
Box::new(map),
DEFAULT_TAG,
AccessMode::ReadWrite,
))
Self(Union::Map(Box::new(map), DEFAULT_TAG, ReadWrite))
}
}
#[cfg(not(feature = "no_object"))]
@ -1929,7 +1909,7 @@ impl<K: Into<crate::Identifier>, T: Variant + Clone> From<std::collections::Hash
.collect(),
),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
}
@ -1947,45 +1927,33 @@ impl<K: Into<crate::Identifier>, T: Variant + Clone> From<std::collections::BTre
.collect(),
),
DEFAULT_TAG,
AccessMode::ReadWrite,
ReadWrite,
))
}
}
impl From<FnPtr> for Dynamic {
#[inline(always)]
fn from(value: FnPtr) -> Self {
Self(Union::FnPtr(
Box::new(value),
DEFAULT_TAG,
AccessMode::ReadWrite,
))
Self(Union::FnPtr(Box::new(value), DEFAULT_TAG, ReadWrite))
}
}
impl From<Box<FnPtr>> for Dynamic {
#[inline(always)]
fn from(value: Box<FnPtr>) -> Self {
Self(Union::FnPtr(value, DEFAULT_TAG, AccessMode::ReadWrite))
Self(Union::FnPtr(value, DEFAULT_TAG, ReadWrite))
}
}
#[cfg(not(feature = "no_std"))]
impl From<Instant> for Dynamic {
#[inline(always)]
fn from(value: Instant) -> Self {
Self(Union::TimeStamp(
Box::new(value),
DEFAULT_TAG,
AccessMode::ReadWrite,
))
Self(Union::TimeStamp(Box::new(value), DEFAULT_TAG, ReadWrite))
}
}
#[cfg(not(feature = "no_closure"))]
impl From<crate::Shared<crate::Locked<Dynamic>>> for Dynamic {
#[inline(always)]
fn from(value: crate::Shared<crate::Locked<Self>>) -> Self {
Self(Union::Shared(
value.into(),
DEFAULT_TAG,
AccessMode::ReadWrite,
))
Self(Union::Shared(value.into(), DEFAULT_TAG, ReadWrite))
}
}

82
src/engine.rs
View File

@ -263,7 +263,7 @@ enum ChainArgument {
Property(Position),
/// Arguments to a dot method call.
#[cfg(not(feature = "no_object"))]
MethodCallArgs(StaticVec<Dynamic>, StaticVec<Position>),
MethodCallArgs(StaticVec<Dynamic>, Position),
/// Index value.
#[cfg(not(feature = "no_index"))]
IndexValue(Dynamic, Position),
@ -294,7 +294,7 @@ impl ChainArgument {
/// Panics if not `ChainArgument::MethodCallArgs`.
#[inline(always)]
#[cfg(not(feature = "no_object"))]
pub fn as_fn_call_args(self) -> (StaticVec<Dynamic>, StaticVec<Position>) {
pub fn as_fn_call_args(self) -> (StaticVec<Dynamic>, Position) {
match self {
Self::Property(_) => {
panic!("expecting ChainArgument::MethodCallArgs")
@ -303,16 +303,16 @@ impl ChainArgument {
Self::IndexValue(_, _) => {
panic!("expecting ChainArgument::MethodCallArgs")
}
Self::MethodCallArgs(values, positions) => (values, positions),
Self::MethodCallArgs(values, pos) => (values, pos),
}
}
}
#[cfg(not(feature = "no_object"))]
impl From<(StaticVec<Dynamic>, StaticVec<Position>)> for ChainArgument {
impl From<(StaticVec<Dynamic>, Position)> for ChainArgument {
#[inline(always)]
fn from((values, positions): (StaticVec<Dynamic>, StaticVec<Position>)) -> Self {
Self::MethodCallArgs(values, positions)
fn from((values, pos): (StaticVec<Dynamic>, Position)) -> Self {
Self::MethodCallArgs(values, pos)
}
}
@ -787,7 +787,7 @@ pub struct Engine {
/// A module resolution service.
#[cfg(not(feature = "no_module"))]
pub(crate) module_resolver: Box<dyn crate::ModuleResolver>,
pub(crate) module_resolver: Option<Box<dyn crate::ModuleResolver>>,
/// A map mapping type names to pretty-print names.
pub(crate) type_names: BTreeMap<Identifier, Box<Identifier>>,
@ -890,10 +890,10 @@ impl Engine {
#[cfg(not(feature = "no_module"))]
#[cfg(not(feature = "no_std"))]
#[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))]
module_resolver: Box::new(crate::module::resolvers::FileModuleResolver::new()),
module_resolver: Some(Box::new(crate::module::resolvers::FileModuleResolver::new())),
#[cfg(not(feature = "no_module"))]
#[cfg(any(feature = "no_std", target_arch = "wasm32",))]
module_resolver: Box::new(crate::module::resolvers::DummyModuleResolver::new()),
module_resolver: None,
type_names: Default::default(),
empty_string: Default::default(),
@ -950,7 +950,7 @@ impl Engine {
global_sub_modules: Default::default(),
#[cfg(not(feature = "no_module"))]
module_resolver: Box::new(crate::module::resolvers::DummyModuleResolver::new()),
module_resolver: None,
type_names: Default::default(),
empty_string: Default::default(),
@ -1629,24 +1629,25 @@ impl Engine {
match expr {
#[cfg(not(feature = "no_object"))]
Expr::FnCall(x, _) if _parent_chain_type == ChainType::Dot && !x.is_qualified() => {
let mut arg_positions: StaticVec<_> = Default::default();
let mut arg_values = x
let arg_values = x
.args
.iter()
.inspect(|arg_expr| arg_positions.push(arg_expr.position()))
.map(|arg_expr| {
self.eval_expr(scope, mods, state, lib, this_ptr, arg_expr, level)
.map(Dynamic::flatten)
})
.chain(x.literal_args.iter().map(|(v, _)| Ok(v.clone())))
.collect::<Result<StaticVec<_>, _>>()?;
x.literal_args
let pos = x
.args
.iter()
.inspect(|(_, pos)| arg_positions.push(*pos))
.for_each(|(v, _)| arg_values.push(v.clone()));
.map(|arg_expr| arg_expr.position())
.chain(x.literal_args.iter().map(|(_, pos)| *pos))
.next()
.unwrap_or_default();
idx_values.push((arg_values, arg_positions).into());
idx_values.push((arg_values, pos).into());
}
#[cfg(not(feature = "no_object"))]
Expr::FnCall(_, _) if _parent_chain_type == ChainType::Dot => {
@ -1674,24 +1675,25 @@ impl Engine {
Expr::FnCall(x, _)
if _parent_chain_type == ChainType::Dot && !x.is_qualified() =>
{
let mut arg_positions: StaticVec<_> = Default::default();
let mut arg_values = x
let arg_values = x
.args
.iter()
.inspect(|arg_expr| arg_positions.push(arg_expr.position()))
.map(|arg_expr| {
self.eval_expr(scope, mods, state, lib, this_ptr, arg_expr, level)
.map(Dynamic::flatten)
})
.chain(x.literal_args.iter().map(|(v, _)| Ok(v.clone())))
.collect::<Result<StaticVec<_>, _>>()?;
x.literal_args
let pos = x
.args
.iter()
.inspect(|(_, pos)| arg_positions.push(*pos))
.for_each(|(v, _)| arg_values.push(v.clone()));
.map(|arg_expr| arg_expr.position())
.chain(x.literal_args.iter().map(|(_, pos)| *pos))
.next()
.unwrap_or_default();
(arg_values, arg_positions).into()
(arg_values, pos).into()
}
#[cfg(not(feature = "no_object"))]
Expr::FnCall(_, _) if _parent_chain_type == ChainType::Dot => {
@ -2037,11 +2039,7 @@ impl Engine {
Expr::Unit(_) => Ok(Dynamic::UNIT),
Expr::Custom(custom, _) => {
let expressions = custom
.keywords
.iter()
.map(Into::into)
.collect::<StaticVec<_>>();
let expressions: StaticVec<_> = custom.keywords.iter().map(Into::into).collect();
let key_token = custom.tokens.first().expect(
"never fails because a custom syntax stream must contain at least one token",
);
@ -2757,20 +2755,26 @@ impl Engine {
use crate::ModuleResolver;
let source = state.source.as_ref().map(|s| s.as_str());
let expr_pos = expr.position();
let path_pos = expr.position();
let module = state
.resolver
.as_ref()
.and_then(|r| match r.resolve(self, source, &path, expr_pos) {
Ok(m) => return Some(Ok(m)),
Err(err) => match *err {
EvalAltResult::ErrorModuleNotFound(_, _) => None,
_ => return Some(Err(err)),
},
.and_then(|r| match r.resolve(self, source, &path, path_pos) {
Err(err)
if matches!(*err, EvalAltResult::ErrorModuleNotFound(_, _)) =>
{
None
}
result => Some(result),
})
.or_else(|| {
self.module_resolver
.as_ref()
.map(|r| r.resolve(self, source, &path, path_pos))
})
.unwrap_or_else(|| {
self.module_resolver.resolve(self, source, &path, expr_pos)
EvalAltResult::ErrorModuleNotFound(path.to_string(), path_pos).into()
})?;
export.as_ref().map(|x| x.name.clone()).map(|name| {

18
src/engine_api.rs
View File

@ -1101,8 +1101,10 @@ impl Engine {
});
}
let mut resolver = StaticModuleResolver::new();
let mut ast = self.compile_scripts_with_scope(scope, &[script])?;
if let Some(ref module_resolver) = self.module_resolver {
let mut resolver = StaticModuleResolver::new();
let mut imports = Default::default();
collect_imports(&ast, &mut resolver, &mut imports);
@ -1111,10 +1113,7 @@ impl Engine {
while let Some(path) = imports.iter().next() {
let path = path.clone();
match self
.module_resolver
.resolve_ast(self, None, &path, Position::NONE)
{
match module_resolver.resolve_ast(self, None, &path, Position::NONE) {
Some(Ok(module_ast)) => {
collect_imports(&module_ast, &mut resolver, &mut imports)
}
@ -1122,18 +1121,15 @@ impl Engine {
None => (),
}
let module = shared_take_or_clone(self.module_resolver.resolve(
self,
None,
&path,
Position::NONE,
)?);
let module = module_resolver.resolve(self, None, &path, Position::NONE)?;
let module = shared_take_or_clone(module);
imports.remove(&path);
resolver.insert(path, module);
}
ast.set_resolver(resolver);
}
}
Ok(ast)
}

2
src/engine_settings.rs
View File

@ -188,7 +188,7 @@ impl Engine {
&mut self,
resolver: impl crate::ModuleResolver + 'static,
) -> &mut Self {
self.module_resolver = Box::new(resolver);
self.module_resolver = Some(Box::new(resolver));
self
}
/// Disable a particular keyword or operator in the language.

62
src/fn_call.rs
View File

@ -515,13 +515,11 @@ impl Engine {
);
// Merge in encapsulated environment, if any
let lib_merged;
let lib_merged: StaticVec<_>;
let (unified_lib, unified) = if let Some(ref env_lib) = fn_def.lib {
state.push_fn_resolution_cache();
lib_merged = once(env_lib.as_ref())
.chain(lib.iter().cloned())
.collect::<StaticVec<_>>();
lib_merged = once(env_lib.as_ref()).chain(lib.iter().cloned()).collect();
(lib_merged.as_ref(), true)
} else {
(lib, false)
@ -895,20 +893,16 @@ impl Engine {
fn_name: &str,
mut hash: FnCallHashes,
target: &mut crate::engine::Target,
(call_args, call_arg_positions): &mut (StaticVec<Dynamic>, StaticVec<Position>),
(call_args, call_arg_pos): &mut (StaticVec<Dynamic>, Position),
pos: Position,
level: usize,
) -> Result<(Dynamic, bool), Box<EvalAltResult>> {
let is_ref = target.is_ref();
// Get a reference to the mutation target Dynamic
let obj = target.as_mut();
let mut fn_name = fn_name;
let (result, updated) = match fn_name {
KEYWORD_FN_PTR_CALL if obj.is::<FnPtr>() => {
KEYWORD_FN_PTR_CALL if target.is::<FnPtr>() => {
// FnPtr call
let fn_ptr = obj
let fn_ptr = target
.read_lock::<FnPtr>()
.expect("never fails because `obj` is `FnPtr`");
// Redirect function name
@ -917,11 +911,8 @@ impl Engine {
// Recalculate hashes
let new_hash = FnCallHashes::from_script(calc_fn_hash(fn_name, args_len));
// Arguments are passed as-is, adding the curried arguments
let mut curry = fn_ptr.curry().iter().cloned().collect::<StaticVec<_>>();
let mut args = curry
.iter_mut()
.chain(call_args.iter_mut())
.collect::<StaticVec<_>>();
let mut curry: StaticVec<_> = fn_ptr.curry().iter().cloned().collect();
let mut args: StaticVec<_> = curry.iter_mut().chain(call_args.iter_mut()).collect();
// Map it to name(args) in function-call style
self.exec_fn_call(
@ -932,20 +923,19 @@ impl Engine {
if call_args.len() > 0 {
if !call_args[0].is::<FnPtr>() {
return Err(self.make_type_mismatch_err::<FnPtr>(
self.map_type_name(obj.type_name()),
call_arg_positions[0],
self.map_type_name(target.type_name()),
*call_arg_pos,
));
}
} else {
return Err(self.make_type_mismatch_err::<FnPtr>(
self.map_type_name(obj.type_name()),
self.map_type_name(target.type_name()),
pos,
));
}
// FnPtr call on object
let fn_ptr = call_args.remove(0).cast::<FnPtr>();
call_arg_positions.remove(0);
// Redirect function name
let fn_name = fn_ptr.fn_name();
let args_len = call_args.len() + fn_ptr.curry().len();
@ -955,11 +945,11 @@ impl Engine {
calc_fn_hash(fn_name, args_len + 1),
);
// Replace the first argument with the object pointer, adding the curried arguments
let mut curry = fn_ptr.curry().iter().cloned().collect::<StaticVec<_>>();
let mut args = once(obj)
let mut curry: StaticVec<_> = fn_ptr.curry().iter().cloned().collect();
let mut args: StaticVec<_> = once(target.as_mut())
.chain(curry.iter_mut())
.chain(call_args.iter_mut())
.collect::<StaticVec<_>>();
.collect();
// Map it to name(args) in function-call style
self.exec_fn_call(
@ -967,14 +957,14 @@ impl Engine {
)
}
KEYWORD_FN_PTR_CURRY => {
if !obj.is::<FnPtr>() {
if !target.is::<FnPtr>() {
return Err(self.make_type_mismatch_err::<FnPtr>(
self.map_type_name(obj.type_name()),
self.map_type_name(target.type_name()),
pos,
));
}
let fn_ptr = obj
let fn_ptr = target
.read_lock::<FnPtr>()
.expect("never fails because `obj` is `FnPtr`");
@ -1005,26 +995,21 @@ impl Engine {
}
_ => {
let mut fn_name = fn_name;
let _redirected;
// Check if it is a map method call in OOP style
#[cfg(not(feature = "no_object"))]
if let Some(map) = obj.read_lock::<Map>() {
if let Some(map) = target.read_lock::<Map>() {
if let Some(val) = map.get(fn_name) {
if let Some(fn_ptr) = val.read_lock::<FnPtr>() {
// Remap the function name
_redirected = fn_ptr.get_fn_name().clone();
fn_name = &_redirected;
// Add curried arguments
fn_ptr
.curry()
.iter()
.cloned()
.enumerate()
.for_each(|(i, v)| {
call_args.insert(i, v);
call_arg_positions.insert(i, Position::NONE);
});
if fn_ptr.is_curried() {
call_args.insert_many(0, fn_ptr.curry().iter().cloned());
}
// Recalculate the hash based on the new function name and new arguments
hash = FnCallHashes::from_script_and_native(
calc_fn_hash(fn_name, call_args.len()),
@ -1035,9 +1020,8 @@ impl Engine {
};
// Attached object pointer in front of the arguments
let mut args = once(obj)
.chain(call_args.iter_mut())
.collect::<StaticVec<_>>();
let mut args: StaticVec<_> =
once(target.as_mut()).chain(call_args.iter_mut()).collect();
self.exec_fn_call(
mods, state, lib, fn_name, hash, &mut args, is_ref, true, pos, None, level,

4
src/fn_func.rs
View File

@ -4,7 +4,7 @@
#![allow(non_snake_case)]
use crate::dynamic::Variant;
use crate::{Engine, EvalAltResult, ParseError, Scope, AST};
use crate::{Engine, EvalAltResult, ParseError, Scope, SmartString, AST};
#[cfg(feature = "no_std")]
use std::prelude::v1::*;
@ -98,7 +98,7 @@ macro_rules! def_anonymous_fn {
#[inline(always)]
fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output {
let fn_name = entry_point.to_string();
let fn_name: SmartString = entry_point.into();
Box::new(move |$($par),*| self.call_fn(&mut Scope::new(), &ast, &fn_name, ($($par,)*)))
}

9
src/fn_native.rs
View File

@ -314,6 +314,11 @@ impl FnPtr {
pub fn is_curried(&self) -> bool {
!self.1.is_empty()
}
/// Get the number of curried arguments.
#[inline(always)]
pub fn num_curried(&self) -> usize {
self.1.len()
}
/// Does the function pointer refer to an anonymous function?
///
/// Not available under `no_function`.
@ -339,7 +344,7 @@ impl FnPtr {
this_ptr: Option<&mut Dynamic>,
mut arg_values: impl AsMut<[Dynamic]>,
) -> RhaiResult {
let mut args_data;
let mut args_data: StaticVec<_>;
let arg_values = if self.curry().is_empty() {
arg_values.as_mut()
@ -349,7 +354,7 @@ impl FnPtr {
.iter()
.cloned()
.chain(arg_values.as_mut().iter_mut().map(mem::take))
.collect::<StaticVec<_>>();
.collect();
args_data.as_mut()
};

2
src/optimize.rs
View File

@ -147,7 +147,7 @@ fn call_fn_with_constant_arguments(
state.lib,
fn_name,
calc_fn_hash(fn_name, arg_values.len()),
arg_values.iter_mut().collect::<StaticVec<_>>().as_mut(),
&mut arg_values.iter_mut().collect::<StaticVec<_>>(),
false,
false,
Position::NONE,

2
src/packages/array_basic.rs
View File

@ -745,7 +745,7 @@ mod array_functions {
len as usize
};
let mut drained = array.drain(..start).collect::<Array>();
let mut drained: Array = array.drain(..start).collect();
drained.extend(array.drain(len..));
drained

2
src/packages/string_more.rs
View File

@ -110,7 +110,7 @@ mod string_functions {
pub fn index_of_char_starting_from(string: &str, character: char, start: INT) -> INT {
let start = if start < 0 {
if let Some(n) = start.checked_abs() {
let chars = string.chars().collect::<Vec<_>>();
let chars: Vec<_> = string.chars().collect();
let num_chars = chars.len();
if n as usize > num_chars {
0

2
src/parser.rs
View File

@ -1864,7 +1864,7 @@ fn parse_custom_syntax(
state.stack.push((empty, AccessMode::ReadWrite));
}
let parse_func = &syntax.parse;
let parse_func = syntax.parse.as_ref();
segments.push(key.into());
tokens.push(key.into());