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

Make parameters order uniform.

Browse Source
This commit is contained in:
Stephen Chung 2022-11-04 21:47:09 +08:00
parent 0756994038
commit 35b02ce9b7
14 changed files with 284 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/api/call_fn.rs
View File

@ -260,7 +260,7 @@ impl Engine {
);
let result = if eval_ast && !statements.is_empty() {
let r = self.eval_global_statements(scope, global, caches, statements, lib, 0);
let r = self.eval_global_statements(global, caches, lib, 0, scope, statements);
if rewind_scope {
scope.rewind(orig_scope_len);
@ -279,16 +279,16 @@ impl Engine {
if let Some(fn_def) = ast.shared_lib().get_script_fn(name, args.len()) {
self.call_script_fn(
scope,
global,
caches,
lib,
0,
scope,
&mut this_ptr,
fn_def,
&mut args,
rewind_scope,
Position::NONE,
0,
)
} else {
Err(ERR::ErrorFunctionNotFound(name.into(), Position::NONE).into())
@ -306,7 +306,7 @@ impl Engine {
if self.debugger.is_some() {
global.debugger.status = crate::eval::DebuggerStatus::Terminate;
let node = &crate::ast::Stmt::Noop(Position::NONE);
self.run_debugger(scope, global, lib, &mut this_ptr, node, 0)?;
self.run_debugger(global, caches, lib, 0, scope, &mut this_ptr, node)?;
}
Ok(result)

20
src/api/eval.rs
View File

@ -186,8 +186,9 @@ impl Engine {
ast: &AST,
) -> RhaiResultOf<T> {
let global = &mut GlobalRuntimeState::new(self);
let caches = &mut Caches::new();
let result = self.eval_ast_with_scope_raw(scope, global, ast, 0)?;
let result = self.eval_ast_with_scope_raw(global, caches, 0, scope, ast)?;
#[cfg(feature = "debugging")]
if self.debugger.is_some() {
@ -197,7 +198,7 @@ impl Engine {
ast.as_ref(),
];
let node = &crate::ast::Stmt::Noop(Position::NONE);
self.run_debugger(scope, global, lib, &mut None, node, 0)?;
self.run_debugger(global, caches, lib, 0, scope, &mut None, node)?;
}
let typ = self.map_type_name(result.type_name());
@ -211,12 +212,12 @@ impl Engine {
#[inline]
pub(crate) fn eval_ast_with_scope_raw<'a>(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
ast: &'a AST,
caches: &mut Caches,
level: usize,
scope: &mut Scope,
ast: &'a AST,
) -> RhaiResult {
let mut caches = Caches::new();
global.source = ast.source_raw().cloned();
#[cfg(not(feature = "no_module"))]
@ -240,8 +241,7 @@ impl Engine {
_lib = &[];
}
let result =
self.eval_global_statements(scope, global, &mut caches, statements, _lib, level);
let result = self.eval_global_statements(global, caches, _lib, level, scope, statements);
#[cfg(not(feature = "no_module"))]
{
@ -262,14 +262,14 @@ impl Engine {
#[inline(always)]
pub fn eval_statements_raw(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
statements: &[crate::ast::Stmt],
lib: &[&crate::Module],
level: usize,
scope: &mut Scope,
statements: &[crate::ast::Stmt],
) -> RhaiResult {
self.eval_global_statements(scope, global, caches, statements, lib, level)
self.eval_global_statements(global, caches, lib, level, scope, statements)
}
}

4
src/api/run.rs
View File

@ -131,7 +131,7 @@ impl Engine {
} else {
&lib
};
self.eval_global_statements(scope, global, caches, statements, lib, 0)?;
self.eval_global_statements(global, caches, lib, 0, scope, statements)?;
}
#[cfg(feature = "debugging")]
@ -142,7 +142,7 @@ impl Engine {
ast.as_ref(),
];
let node = &crate::ast::Stmt::Noop(crate::Position::NONE);
self.run_debugger(scope, global, lib, &mut None, node, 0)?;
self.run_debugger(global, caches, lib, 0, scope, &mut None, node)?;
}
Ok(())

171
src/eval/chaining.rs
View File

@ -41,6 +41,7 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
this_ptr: &mut Option<&mut Dynamic>,
target: &mut Target,
root: (&str, Position),
@ -49,7 +50,6 @@ impl Engine {
rhs: &Expr,
idx_values: &mut FnArgsVec<Dynamic>,
chain_type: ChainType,
level: usize,
new_val: &mut Option<(Dynamic, &OpAssignment)>,
) -> RhaiResultOf<(Dynamic, bool)> {
let is_ref_mut = target.is_ref();
@ -73,7 +73,7 @@ impl Engine {
if !parent_options.contains(ASTFlags::BREAK) =>
{
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, _parent, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, _parent)?;
let idx_val = &mut idx_values.pop().unwrap();
let mut idx_val_for_setter = idx_val.clone();
@ -82,14 +82,14 @@ impl Engine {
let (try_setter, result) = {
let mut obj = self.get_indexed_mut(
global, caches, lib, target, idx_val, idx_pos, false, true, level,
global, caches, lib, level, target, idx_val, idx_pos, false, true,
)?;
let is_obj_temp_val = obj.is_temp_value();
let obj_ptr = &mut obj;
match self.eval_dot_index_chain_helper(
global, caches, lib, this_ptr, obj_ptr, root, rhs, *options,
&x.rhs, idx_values, rhs_chain, level, new_val,
global, caches, lib, level, this_ptr, obj_ptr, root, rhs, *options,
&x.rhs, idx_values, rhs_chain, new_val,
) {
Ok((result, true)) if is_obj_temp_val => {
(Some(obj.take_or_clone()), (result, true))
@ -104,7 +104,7 @@ impl Engine {
let idx = &mut idx_val_for_setter;
let new_val = &mut new_val;
self.call_indexer_set(
global, caches, lib, target, idx, new_val, is_ref_mut, level,
global, caches, lib, level, target, idx, new_val, is_ref_mut,
)
.or_else(|e| match *e {
ERR::ErrorIndexingType(..) => Ok((Dynamic::UNIT, false)),
@ -117,19 +117,19 @@ impl Engine {
// xxx[rhs] op= new_val
_ if new_val.is_some() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, _parent, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, _parent)?;
let (new_val, op_info) = new_val.take().expect("`Some`");
let idx_val = &mut idx_values.pop().unwrap();
let idx = &mut idx_val.clone();
let try_setter = match self.get_indexed_mut(
global, caches, lib, target, idx, pos, true, false, level,
global, caches, lib, level, target, idx, pos, true, false,
) {
// Indexed value is not a temp value - update directly
Ok(ref mut obj_ptr) => {
self.eval_op_assignment(
global, caches, lib, op_info, obj_ptr, root, new_val, level,
global, caches, lib, level, op_info, obj_ptr, root, new_val,
)?;
self.check_data_size(obj_ptr, op_info.pos)?;
None
@ -148,13 +148,13 @@ impl Engine {
// Call the index getter to get the current value
if let Ok(val) =
self.call_indexer_get(global, caches, lib, target, idx, level)
self.call_indexer_get(global, caches, lib, level, target, idx)
{
let mut val = val.into();
// Run the op-assignment
self.eval_op_assignment(
global, caches, lib, op_info, &mut val, root, new_val,
level,
global, caches, lib, level, op_info, &mut val, root,
new_val,
)?;
// Replace new value
new_val = val.take_or_clone();
@ -166,7 +166,7 @@ impl Engine {
let new_val = &mut new_val;
self.call_indexer_set(
global, caches, lib, target, idx_val, new_val, is_ref_mut, level,
global, caches, lib, level, target, idx_val, new_val, is_ref_mut,
)?;
}
@ -175,12 +175,12 @@ impl Engine {
// xxx[rhs]
_ => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, _parent, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, _parent)?;
let idx_val = &mut idx_values.pop().unwrap();
self.get_indexed_mut(
global, caches, lib, target, idx_val, pos, false, true, level,
global, caches, lib, level, target, idx_val, pos, false, true,
)
.map(|v| (v.take_or_clone(), false))
}
@ -198,8 +198,9 @@ impl Engine {
// xxx.fn_name(arg_expr_list)
Expr::MethodCall(x, pos) if !x.is_qualified() && new_val.is_none() => {
#[cfg(feature = "debugging")]
let reset_debugger =
self.run_debugger_with_reset(scope, global, lib, this_ptr, rhs, level)?;
let reset_debugger = self.run_debugger_with_reset(
global, caches, lib, level, scope, this_ptr, rhs,
)?;
let crate::ast::FnCallExpr {
name, hashes, args, ..
@ -210,8 +211,8 @@ impl Engine {
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
let result = self.make_method_call(
global, caches, lib, name, *hashes, target, call_args, pos1, *pos,
level,
global, caches, lib, level, name, *hashes, target, call_args, pos1,
*pos,
);
idx_values.truncate(offset);
@ -232,16 +233,16 @@ impl Engine {
// {xxx:map}.id op= ???
Expr::Property(x, pos) if target.is::<crate::Map>() && new_val.is_some() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, rhs, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, rhs)?;
let index = &mut x.2.clone().into();
let (new_val, op_info) = new_val.take().expect("`Some`");
{
let val_target = &mut self.get_indexed_mut(
global, caches, lib, target, index, *pos, true, false, level,
global, caches, lib, level, target, index, *pos, true, false,
)?;
self.eval_op_assignment(
global, caches, lib, op_info, val_target, root, new_val, level,
global, caches, lib, level, op_info, val_target, root, new_val,
)?;
}
self.check_data_size(target.source(), op_info.pos)?;
@ -250,18 +251,18 @@ impl Engine {
// {xxx:map}.id
Expr::Property(x, pos) if target.is::<crate::Map>() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, rhs, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, rhs)?;
let index = &mut x.2.clone().into();
let val = self.get_indexed_mut(
global, caches, lib, target, index, *pos, false, false, level,
global, caches, lib, level, target, index, *pos, false, false,
)?;
Ok((val.take_or_clone(), false))
}
// xxx.id op= ???
Expr::Property(x, pos) if new_val.is_some() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, rhs, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, rhs)?;
let ((getter, hash_get), (setter, hash_set), name) = &**x;
let (mut new_val, op_info) = new_val.take().expect("`Some`");
@ -270,15 +271,15 @@ impl Engine {
let args = &mut [target.as_mut()];
let (mut orig_val, ..) = self
.exec_native_fn_call(
global, caches, lib, getter, None, *hash_get, args, is_ref_mut,
*pos, level,
global, caches, lib, level, getter, None, *hash_get, args,
is_ref_mut, *pos,
)
.or_else(|err| match *err {
// Try an indexer if property does not exist
ERR::ErrorDotExpr(..) => {
let mut prop = name.into();
self.call_indexer_get(
global, caches, lib, target, &mut prop, level,
global, caches, lib, level, target, &mut prop,
)
.map(|r| (r, false))
.map_err(|e| {
@ -295,7 +296,7 @@ impl Engine {
let orig_val = &mut (&mut orig_val).into();
self.eval_op_assignment(
global, caches, lib, op_info, orig_val, root, new_val, level,
global, caches, lib, level, op_info, orig_val, root, new_val,
)?;
}
@ -304,8 +305,8 @@ impl Engine {
let args = &mut [target.as_mut(), &mut new_val];
self.exec_native_fn_call(
global, caches, lib, setter, None, *hash_set, args, is_ref_mut, *pos,
level,
global, caches, lib, level, setter, None, *hash_set, args, is_ref_mut,
*pos,
)
.or_else(|err| match *err {
// Try an indexer if property does not exist
@ -313,7 +314,7 @@ impl Engine {
let idx = &mut name.into();
let new_val = &mut new_val;
self.call_indexer_set(
global, caches, lib, target, idx, new_val, is_ref_mut, level,
global, caches, lib, level, target, idx, new_val, is_ref_mut,
)
.map_err(|e| match *e {
ERR::ErrorIndexingType(..) => err,
@ -326,13 +327,13 @@ impl Engine {
// xxx.id
Expr::Property(x, pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, rhs, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, rhs)?;
let ((getter, hash_get), _, name) = &**x;
let args = &mut [target.as_mut()];
self.exec_native_fn_call(
global, caches, lib, getter, None, *hash_get, args, is_ref_mut, *pos,
level,
global, caches, lib, level, getter, None, *hash_get, args, is_ref_mut,
*pos,
)
.map_or_else(
|err| match *err {
@ -340,7 +341,7 @@ impl Engine {
ERR::ErrorDotExpr(..) => {
let mut prop = name.into();
self.call_indexer_get(
global, caches, lib, target, &mut prop, level,
global, caches, lib, level, target, &mut prop,
)
.map(|r| (r, false))
.map_err(|e| match *e {
@ -363,18 +364,20 @@ impl Engine {
let val_target = &mut match x.lhs {
Expr::Property(ref p, pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, _node, level)?;
self.run_debugger(
global, caches, lib, level, scope, this_ptr, _node,
)?;
let index = &mut p.2.clone().into();
self.get_indexed_mut(
global, caches, lib, target, index, pos, false, true, level,
global, caches, lib, level, target, index, pos, false, true,
)?
}
// {xxx:map}.fn_name(arg_expr_list)[expr] | {xxx:map}.fn_name(arg_expr_list).expr
Expr::MethodCall(ref x, pos) if !x.is_qualified() => {
#[cfg(feature = "debugging")]
let reset_debugger = self.run_debugger_with_reset(
scope, global, lib, this_ptr, _node, level,
global, caches, lib, level, scope, this_ptr, _node,
)?;
let crate::ast::FnCallExpr {
@ -386,8 +389,8 @@ impl Engine {
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
let result = self.make_method_call(
global, caches, lib, name, *hashes, target, call_args, pos1,
pos, level,
global, caches, lib, level, name, *hashes, target, call_args,
pos1, pos,
);
idx_values.truncate(offset);
@ -407,8 +410,8 @@ impl Engine {
let rhs_chain = rhs.into();
self.eval_dot_index_chain_helper(
global, caches, lib, this_ptr, val_target, root, rhs, *options, &x.rhs,
idx_values, rhs_chain, level, new_val,
global, caches, lib, level, this_ptr, val_target, root, rhs, *options,
&x.rhs, idx_values, rhs_chain, new_val,
)
.map_err(|err| err.fill_position(*x_pos))
}
@ -420,7 +423,9 @@ impl Engine {
// xxx.prop[expr] | xxx.prop.expr
Expr::Property(ref p, pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, _node, level)?;
self.run_debugger(
global, caches, lib, level, scope, this_ptr, _node,
)?;
let ((getter, hash_get), (setter, hash_set), name) = &**p;
let rhs_chain = rhs.into();
@ -430,15 +435,15 @@ impl Engine {
// Assume getters are always pure
let (mut val, ..) = self
.exec_native_fn_call(
global, caches, lib, getter, None, *hash_get, args,
is_ref_mut, pos, level,
global, caches, lib, level, getter, None, *hash_get, args,
is_ref_mut, pos,
)
.or_else(|err| match *err {
// Try an indexer if property does not exist
ERR::ErrorDotExpr(..) => {
let mut prop = name.into();
self.call_indexer_get(
global, caches, lib, target, &mut prop, level,
global, caches, lib, level, target, &mut prop,
)
.map(|r| (r, false))
.map_err(
@ -455,8 +460,8 @@ impl Engine {
let (result, may_be_changed) = self
.eval_dot_index_chain_helper(
global, caches, lib, this_ptr, val, root, rhs, *options,
&x.rhs, idx_values, rhs_chain, level, new_val,
global, caches, lib, level, this_ptr, val, root, rhs,
*options, &x.rhs, idx_values, rhs_chain, new_val,
)
.map_err(|err| err.fill_position(*x_pos))?;
@ -466,8 +471,8 @@ impl Engine {
let mut arg_values = [target.as_mut(), val.as_mut()];
let args = &mut arg_values;
self.exec_native_fn_call(
global, caches, lib, setter, None, *hash_set, args,
is_ref_mut, pos, level,
global, caches, lib, level, setter, None, *hash_set, args,
is_ref_mut, pos,
)
.or_else(
|err| match *err {
@ -476,8 +481,8 @@ impl Engine {
let idx = &mut name.into();
let new_val = val;
self.call_indexer_set(
global, caches, lib, target, idx, new_val,
is_ref_mut, level,
global, caches, lib, level, target, idx,
new_val, is_ref_mut,
)
.or_else(|e| match *e {
// If there is no setter, no need to feed it
@ -499,7 +504,7 @@ impl Engine {
Expr::MethodCall(ref f, pos) if !f.is_qualified() => {
#[cfg(feature = "debugging")]
let reset_debugger = self.run_debugger_with_reset(
scope, global, lib, this_ptr, _node, level,
global, caches, lib, level, scope, this_ptr, _node,
)?;
let crate::ast::FnCallExpr {
@ -512,8 +517,8 @@ impl Engine {
let pos1 = args.get(0).map_or(Position::NONE, Expr::position);
let result = self.make_method_call(
global, caches, lib, name, *hashes, target, call_args, pos1,
pos, level,
global, caches, lib, level, name, *hashes, target, call_args,
pos1, pos,
);
idx_values.truncate(offset);
@ -525,8 +530,8 @@ impl Engine {
let val = &mut val.into();
self.eval_dot_index_chain_helper(
global, caches, lib, this_ptr, val, root, rhs, *options,
&x.rhs, idx_values, rhs_chain, level, new_val,
global, caches, lib, level, this_ptr, val, root, rhs, *options,
&x.rhs, idx_values, rhs_chain, new_val,
)
.map_err(|err| err.fill_position(pos))
}
@ -548,13 +553,13 @@ impl Engine {
/// Evaluate a dot/index chain.
pub(crate) fn eval_dot_index_chain(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
expr: &Expr,
level: usize,
new_val: &mut Option<(Dynamic, &OpAssignment)>,
) -> RhaiResult {
let chain_type = ChainType::from(expr);
@ -592,8 +597,8 @@ impl Engine {
// All other patterns - evaluate the arguments chain
_ => {
self.eval_dot_index_chain_arguments(
scope, global, caches, lib, this_ptr, rhs, options, chain_type, idx_values,
level,
global, caches, lib, level, scope, this_ptr, rhs, options, chain_type,
idx_values,
)?;
}
}
@ -602,18 +607,18 @@ impl Engine {
// id.??? or id[???]
Expr::Variable(x, .., var_pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, lhs, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, lhs)?;
self.track_operation(global, *var_pos)?;
let (mut target, ..) =
self.search_namespace(scope, global, lib, this_ptr, lhs, level)?;
self.search_namespace(global, caches, lib, level, scope, this_ptr, lhs)?;
let obj_ptr = &mut target;
let root = (x.3.as_str(), *var_pos);
self.eval_dot_index_chain_helper(
global, caches, lib, &mut None, obj_ptr, root, expr, options, rhs, idx_values,
chain_type, level, new_val,
global, caches, lib, level, &mut None, obj_ptr, root, expr, options, rhs,
idx_values, chain_type, new_val,
)
}
// {expr}.??? = ??? or {expr}[???] = ???
@ -621,14 +626,14 @@ impl Engine {
// {expr}.??? or {expr}[???]
expr => {
let value = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)?
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)?
.flatten();
let obj_ptr = &mut value.into();
let root = ("", expr.start_position());
self.eval_dot_index_chain_helper(
global, caches, lib, this_ptr, obj_ptr, root, expr, options, rhs, idx_values,
chain_type, level, new_val,
global, caches, lib, level, this_ptr, obj_ptr, root, expr, options, rhs,
idx_values, chain_type, new_val,
)
}
}
@ -639,16 +644,16 @@ impl Engine {
/// Evaluate a chain of indexes and store the results in a [`FnArgsVec`].
fn eval_dot_index_chain_arguments(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
expr: &Expr,
parent_options: ASTFlags,
parent_chain_type: ChainType,
idx_values: &mut FnArgsVec<Dynamic>,
level: usize,
) -> RhaiResultOf<()> {
self.track_operation(global, expr.position())?;
@ -659,7 +664,7 @@ impl Engine {
{
for arg_expr in &x.args {
idx_values.push(
self.get_arg_value(scope, global, caches, lib, this_ptr, arg_expr, level)?
self.get_arg_value(global, caches, lib, level, scope, this_ptr, arg_expr)?
.0
.flatten(),
);
@ -694,7 +699,7 @@ impl Engine {
for arg_expr in &x.args {
_arg_values.push(
self.get_arg_value(
scope, global, caches, lib, this_ptr, arg_expr, level,
global, caches, lib, level, scope, this_ptr, arg_expr,
)?
.0
.flatten(),
@ -712,7 +717,7 @@ impl Engine {
#[cfg(not(feature = "no_index"))]
_ if parent_chain_type == ChainType::Indexing => {
_arg_values.push(
self.eval_expr(scope, global, caches, lib, this_ptr, lhs, level)?
self.eval_expr(global, caches, lib, level, scope, this_ptr, lhs)?
.flatten(),
);
}
@ -723,8 +728,8 @@ impl Engine {
let chain_type = expr.into();
self.eval_dot_index_chain_arguments(
scope, global, caches, lib, this_ptr, rhs, *options, chain_type, idx_values,
level,
global, caches, lib, level, scope, this_ptr, rhs, *options, chain_type,
idx_values,
)?;
if !_arg_values.is_empty() {
@ -738,7 +743,7 @@ impl Engine {
}
#[cfg(not(feature = "no_index"))]
_ if parent_chain_type == ChainType::Indexing => idx_values.push(
self.eval_expr(scope, global, caches, lib, this_ptr, expr, level)?
self.eval_expr(global, caches, lib, level, scope, this_ptr, expr)?
.flatten(),
),
_ => unreachable!("unknown chained expression: {:?}", expr),
@ -754,9 +759,9 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
target: &mut Dynamic,
idx: &mut Dynamic,
level: usize,
) -> RhaiResultOf<Dynamic> {
let args = &mut [target, idx];
let hash = global.hash_idx_get();
@ -765,7 +770,7 @@ impl Engine {
let level = level + 1;
self.exec_native_fn_call(
global, caches, lib, fn_name, None, hash, args, true, pos, level,
global, caches, lib, level, fn_name, None, hash, args, true, pos,
)
.map(|(r, ..)| r)
}
@ -777,11 +782,11 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
target: &mut Dynamic,
idx: &mut Dynamic,
new_val: &mut Dynamic,
is_ref_mut: bool,
level: usize,
) -> RhaiResultOf<(Dynamic, bool)> {
let hash = global.hash_idx_set();
let args = &mut [target, idx, new_val];
@ -790,7 +795,7 @@ impl Engine {
let level = level + 1;
self.exec_native_fn_call(
global, caches, lib, fn_name, None, hash, args, is_ref_mut, pos, level,
global, caches, lib, level, fn_name, None, hash, args, is_ref_mut, pos,
)
}
@ -801,12 +806,12 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
target: &'t mut Dynamic,
idx: &mut Dynamic,
idx_pos: Position,
_add_if_not_found: bool,
use_indexers: bool,
level: usize,
) -> RhaiResultOf<Target<'t>> {
self.track_operation(global, Position::NONE)?;
@ -1010,7 +1015,7 @@ impl Engine {
}
_ if use_indexers => self
.call_indexer_get(global, caches, lib, target, idx, level)
.call_indexer_get(global, caches, lib, level, target, idx)
.map(Into::into),
_ => Err(ERR::ErrorIndexingType(

31
src/eval/debugger.rs
View File

@ -1,7 +1,7 @@
//! Module defining the debugging interface.
#![cfg(feature = "debugging")]
use super::{EvalContext, GlobalRuntimeState};
use super::{Caches, EvalContext, GlobalRuntimeState};
use crate::ast::{ASTNode, Expr, Stmt};
use crate::{
Dynamic, Engine, EvalAltResult, ImmutableString, Module, Position, RhaiResultOf, Scope,
@ -411,16 +411,17 @@ impl Engine {
#[inline(always)]
pub(crate) fn run_debugger<'a>(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
node: impl Into<ASTNode<'a>>,
level: usize,
) -> RhaiResultOf<()> {
if self.debugger.is_some() {
if let Some(cmd) =
self.run_debugger_with_reset_raw(scope, global, lib, this_ptr, node, level)?
self.run_debugger_with_reset_raw(global, caches, lib, level, scope, this_ptr, node)?
{
global.debugger.status = cmd;
}
@ -437,15 +438,16 @@ impl Engine {
#[inline(always)]
pub(crate) fn run_debugger_with_reset<'a>(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
node: impl Into<ASTNode<'a>>,
level: usize,
) -> RhaiResultOf<Option<DebuggerStatus>> {
if self.debugger.is_some() {
self.run_debugger_with_reset_raw(scope, global, lib, this_ptr, node, level)
self.run_debugger_with_reset_raw(global, caches, lib, level, scope, this_ptr, node)
} else {
Ok(None)
}
@ -459,12 +461,13 @@ impl Engine {
#[inline]
pub(crate) fn run_debugger_with_reset_raw<'a>(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
node: impl Into<ASTNode<'a>>,
level: usize,
) -> RhaiResultOf<Option<DebuggerStatus>> {
let node = node.into();
@ -494,7 +497,7 @@ impl Engine {
},
};
self.run_debugger_raw(scope, global, lib, this_ptr, node, event, level)
self.run_debugger_raw(global, caches, lib, level, scope, this_ptr, node, event)
}
/// Run the debugger callback unconditionally.
///
@ -505,17 +508,19 @@ impl Engine {
#[inline]
pub(crate) fn run_debugger_raw<'a>(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
node: ASTNode<'a>,
event: DebuggerEvent,
level: usize,
) -> Result<Option<DebuggerStatus>, Box<crate::EvalAltResult>> {
let src = global.source_raw().cloned();
let src = src.as_ref().map(|s| s.as_str());
let context = crate::EvalContext::new(self, scope, global, None, lib, this_ptr, level);
let context =
crate::EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr);
if let Some((.., ref on_debugger)) = self.debugger {
let command = on_debugger(context, event, node, src, node.position())?;

12
src/eval/eval_context.rs
View File

@ -31,12 +31,12 @@ impl<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'pg, '
#[must_use]
pub fn new(
engine: &'a Engine,
scope: &'s mut Scope<'ps>,
global: &'g mut GlobalRuntimeState<'pg>,
caches: Option<&'c mut Caches<'pc>>,
lib: &'a [&'a Module],
this_ptr: &'t mut Option<&'pt mut Dynamic>,
level: usize,
scope: &'s mut Scope<'ps>,
this_ptr: &'t mut Option<&'pt mut Dynamic>,
) -> Self {
Self {
engine,
@ -182,23 +182,23 @@ impl<'a, 's, 'ps, 'g, 'pg, 'c, 'pc, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'pg, '
match expr {
crate::ast::Expr::Stmt(statements) => self.engine.eval_stmt_block(
self.scope,
self.global,
caches,
self.lib,
self.level,
self.scope,
self.this_ptr,
statements,
rewind_scope,
self.level,
),
_ => self.engine.eval_expr(
self.scope,
self.global,
caches,
self.lib,
self.level,
self.scope,
self.this_ptr,
expr,
self.level,
),
}
}

60
src/eval/expr.rs
View File

@ -49,25 +49,26 @@ impl Engine {
/// depending on whether the variable name is namespace-qualified.
pub(crate) fn search_namespace<'s>(
&self,
scope: &'s mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &'s mut Scope,
this_ptr: &'s mut Option<&mut Dynamic>,
expr: &Expr,
level: usize,
) -> RhaiResultOf<(Target<'s>, Position)> {
match expr {
Expr::Variable(_, Some(_), _) => {
self.search_scope_only(scope, global, lib, this_ptr, expr, level)
self.search_scope_only(global, caches, lib, level, scope, this_ptr, expr)
}
Expr::Variable(v, None, _var_pos) => match &**v {
// Normal variable access
#[cfg(not(feature = "no_module"))]
(_, ns, ..) if ns.is_empty() => {
self.search_scope_only(scope, global, lib, this_ptr, expr, level)
self.search_scope_only(global, caches, lib, level, scope, this_ptr, expr)
}
#[cfg(feature = "no_module")]
(_, (), ..) => self.search_scope_only(scope, global, lib, this_ptr, expr, level),
(_, (), ..) => self.search_scope_only(scope, global, lib, this_ptr, expr),
// Qualified variable access
#[cfg(not(feature = "no_module"))]
@ -132,12 +133,13 @@ impl Engine {
/// Panics if `expr` is not [`Expr::Variable`].
pub(crate) fn search_scope_only<'s>(
&self,
scope: &'s mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &'s mut Scope,
this_ptr: &'s mut Option<&mut Dynamic>,
expr: &Expr,
level: usize,
) -> RhaiResultOf<(Target<'s>, Position)> {
// Make sure that the pointer indirection is taken only when absolutely necessary.
@ -169,7 +171,7 @@ impl Engine {
// Check the variable resolver, if any
if let Some(ref resolve_var) = self.resolve_var {
let context = EvalContext::new(self, scope, global, None, lib, this_ptr, level);
let context = EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr);
let var_name = expr.get_variable_name(true).expect("`Expr::Variable`");
match resolve_var(var_name, index, context) {
Ok(Some(mut result)) => {
@ -215,13 +217,13 @@ impl Engine {
// Errors that are not recoverable, such as system errors or safety errors, can use `?`.
pub(crate) fn eval_expr(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
expr: &Expr,
level: usize,
) -> RhaiResult {
// Coded this way for better branch prediction.
// Popular branches are lifted out of the `match` statement into their own branches.
@ -231,12 +233,12 @@ impl Engine {
if let Expr::FnCall(x, pos) = expr {
#[cfg(feature = "debugging")]
let reset_debugger =
self.run_debugger_with_reset(scope, global, lib, this_ptr, expr, level)?;
self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, expr)?;
self.track_operation(global, expr.position())?;
let result =
self.eval_fn_call_expr(scope, global, caches, lib, this_ptr, x, *pos, level);
self.eval_fn_call_expr(global, caches, lib, level, scope, this_ptr, x, *pos);
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
@ -249,7 +251,7 @@ impl Engine {
// will cost more than the mis-predicted `match` branch.
if let Expr::Variable(x, index, var_pos) = expr {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, expr, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, expr)?;
self.track_operation(global, expr.position())?;
@ -259,14 +261,14 @@ impl Engine {
.cloned()
.ok_or_else(|| ERR::ErrorUnboundThis(*var_pos).into())
} else {
self.search_namespace(scope, global, lib, this_ptr, expr, level)
self.search_namespace(global, caches, lib, level, scope, this_ptr, expr)
.map(|(val, ..)| val.take_or_clone())
};
}
#[cfg(feature = "debugging")]
let reset_debugger =
self.run_debugger_with_reset(scope, global, lib, this_ptr, expr, level)?;
self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, expr)?;
self.track_operation(global, expr.position())?;
@ -293,12 +295,12 @@ impl Engine {
.iter()
.try_for_each(|expr| {
let item =
self.eval_expr(scope, global, caches, lib, this_ptr, expr, level)?;
self.eval_expr(global, caches, lib, level, scope, this_ptr, expr)?;
op_info.pos = expr.start_position();
self.eval_op_assignment(
global, caches, lib, &op_info, target, root, item, level,
global, caches, lib, level, &op_info, target, root, item,
)
})
.map(|_| concat.take_or_clone());
@ -316,7 +318,7 @@ impl Engine {
crate::Array::with_capacity(x.len()),
|mut array, item_expr| {
let value = self
.eval_expr(scope, global, caches, lib, this_ptr, item_expr, level)?
.eval_expr(global, caches, lib, level, scope, this_ptr, item_expr)?
.flatten();
#[cfg(not(feature = "unchecked"))]
@ -348,7 +350,7 @@ impl Engine {
x.0.iter()
.try_fold(x.1.clone(), |mut map, (key, value_expr)| {
let value = self
.eval_expr(scope, global, caches, lib, this_ptr, value_expr, level)?
.eval_expr(global, caches, lib, level, scope, this_ptr, value_expr)?
.flatten();
#[cfg(not(feature = "unchecked"))]
@ -372,7 +374,7 @@ impl Engine {
Expr::And(x, ..) => {
let lhs = self
.eval_expr(scope, global, caches, lib, this_ptr, &x.lhs, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, x.lhs.position())
@ -381,7 +383,7 @@ impl Engine {
match lhs {
Ok(true) => self
.eval_expr(scope, global, caches, lib, this_ptr, &x.rhs, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
.and_then(|v| {
v.as_bool()
.map_err(|typ| {
@ -395,7 +397,7 @@ impl Engine {
Expr::Or(x, ..) => {
let lhs = self
.eval_expr(scope, global, caches, lib, this_ptr, &x.lhs, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, x.lhs.position())
@ -404,7 +406,7 @@ impl Engine {
match lhs {
Ok(false) => self
.eval_expr(scope, global, caches, lib, this_ptr, &x.rhs, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
.and_then(|v| {
v.as_bool()
.map_err(|typ| {
@ -417,11 +419,11 @@ impl Engine {
}
Expr::Coalesce(x, ..) => {
let lhs = self.eval_expr(scope, global, caches, lib, this_ptr, &x.lhs, level);
let lhs = self.eval_expr(global, caches, lib, level, scope, this_ptr, &x.lhs);
match lhs {
Ok(value) if value.is::<()>() => {
self.eval_expr(scope, global, caches, lib, this_ptr, &x.rhs, level)
self.eval_expr(global, caches, lib, level, scope, this_ptr, &x.rhs)
}
_ => lhs,
}
@ -442,7 +444,7 @@ impl Engine {
))
})?;
let mut context =
EvalContext::new(self, scope, global, Some(caches), lib, this_ptr, level);
EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr);
let result = (custom_def.func)(&mut context, &expressions, &custom.state);
@ -451,16 +453,16 @@ impl Engine {
Expr::Stmt(x) if x.is_empty() => Ok(Dynamic::UNIT),
Expr::Stmt(x) => {
self.eval_stmt_block(scope, global, caches, lib, this_ptr, x, true, level)
self.eval_stmt_block(global, caches, lib, level, scope, this_ptr, x, true)
}
#[cfg(not(feature = "no_index"))]
Expr::Index(..) => self
.eval_dot_index_chain(scope, global, caches, lib, this_ptr, expr, level, &mut None),
.eval_dot_index_chain(global, caches, lib, level, scope, this_ptr, expr, &mut None),
#[cfg(not(feature = "no_object"))]
Expr::Dot(..) => self
.eval_dot_index_chain(scope, global, caches, lib, this_ptr, expr, level, &mut None),
.eval_dot_index_chain(global, caches, lib, level, scope, this_ptr, expr, &mut None),
_ => unreachable!("expression cannot be evaluated: {:?}", expr),
};

92
src/eval/stmt.rs
View File

@ -25,14 +25,14 @@ impl Engine {
// Errors that are not recoverable, such as system errors or safety errors, can use `?`.
pub(crate) fn eval_stmt_block(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
statements: &[Stmt],
restore_orig_state: bool,
level: usize,
) -> RhaiResult {
if statements.is_empty() {
return Ok(Dynamic::UNIT);
@ -53,14 +53,14 @@ impl Engine {
let imports_len = global.num_imports();
let result = self.eval_stmt(
scope,
global,
caches,
lib,
level,
scope,
this_ptr,
stmt,
restore_orig_state,
level,
)?;
#[cfg(not(feature = "no_module"))]
@ -113,11 +113,11 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
op_info: &OpAssignment,
target: &mut Target,
root: (&str, Position),
new_val: Dynamic,
level: usize,
) -> RhaiResultOf<()> {
if target.is_read_only() {
// Assignment to constant variable
@ -156,7 +156,7 @@ impl Engine {
let token = Some(op_assign_token);
match self.exec_native_fn_call(
global, caches, lib, op_assign, token, hash, args, true, *op_pos, level,
global, caches, lib, level, op_assign, token, hash, args, true, *op_pos,
) {
Ok(_) => (),
Err(err) if matches!(*err, ERR::ErrorFunctionNotFound(ref f, ..) if f.starts_with(op_assign)) =>
@ -166,7 +166,7 @@ impl Engine {
*args[0] = self
.exec_native_fn_call(
global, caches, lib, op, token, *hash_op, args, true, *op_pos, level,
global, caches, lib, level, op, token, *hash_op, args, true, *op_pos,
)
.map_err(|err| err.fill_position(op_info.pos))?
.0
@ -194,18 +194,18 @@ impl Engine {
// Errors that are not recoverable, such as system errors or safety errors, can use `?`.
pub(crate) fn eval_stmt(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
stmt: &Stmt,
rewind_scope: bool,
level: usize,
) -> RhaiResult {
#[cfg(feature = "debugging")]
let reset_debugger =
self.run_debugger_with_reset(scope, global, lib, this_ptr, stmt, level)?;
self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, stmt)?;
// Coded this way for better branch prediction.
// Popular branches are lifted out of the `match` statement into their own branches.
@ -215,7 +215,7 @@ impl Engine {
self.track_operation(global, stmt.position())?;
let result =
self.eval_fn_call_expr(scope, global, caches, lib, this_ptr, x, *pos, level);
self.eval_fn_call_expr(global, caches, lib, level, scope, this_ptr, x, *pos);
#[cfg(feature = "debugging")]
global.debugger.reset_status(reset_debugger);
@ -233,12 +233,12 @@ impl Engine {
let result = if let Expr::Variable(x, ..) = lhs {
let rhs_result = self
.eval_expr(scope, global, caches, lib, this_ptr, rhs, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, rhs)
.map(Dynamic::flatten);
if let Ok(rhs_val) = rhs_result {
let search_result =
self.search_namespace(scope, global, lib, this_ptr, lhs, level);
self.search_namespace(global, caches, lib, level, scope, this_ptr, lhs);
if let Ok(search_val) = search_result {
let (mut lhs_ptr, pos) = search_val;
@ -265,7 +265,7 @@ impl Engine {
let lhs_ptr = &mut lhs_ptr;
self.eval_op_assignment(
global, caches, lib, op_info, lhs_ptr, root, rhs_val, level,
global, caches, lib, level, op_info, lhs_ptr, root, rhs_val,
)
.map(|_| Dynamic::UNIT)
} else {
@ -277,7 +277,7 @@ impl Engine {
} else {
let (op_info, BinaryExpr { lhs, rhs }) = &**x;
let rhs_result = self.eval_expr(scope, global, caches, lib, this_ptr, rhs, level);
let rhs_result = self.eval_expr(global, caches, lib, level, scope, this_ptr, rhs);
if let Ok(rhs_val) = rhs_result {
// Check if the result is a string. If so, intern it.
@ -307,14 +307,14 @@ impl Engine {
#[cfg(not(feature = "no_index"))]
Expr::Index(..) => self
.eval_dot_index_chain(
scope, global, caches, lib, this_ptr, lhs, level, _new_val,
global, caches, lib, level, scope, this_ptr, lhs, _new_val,
)
.map(|_| Dynamic::UNIT),
// dot_lhs.dot_rhs op= rhs
#[cfg(not(feature = "no_object"))]
Expr::Dot(..) => self
.eval_dot_index_chain(
scope, global, caches, lib, this_ptr, lhs, level, _new_val,
global, caches, lib, level, scope, this_ptr, lhs, _new_val,
)
.map(|_| Dynamic::UNIT),
_ => unreachable!("cannot assign to expression: {:?}", lhs),
@ -338,13 +338,13 @@ impl Engine {
// Expression as statement
Stmt::Expr(expr) => self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.map(Dynamic::flatten),
// Block scope
Stmt::Block(statements, ..) if statements.is_empty() => Ok(Dynamic::UNIT),
Stmt::Block(statements, ..) => self.eval_stmt_block(
scope, global, caches, lib, this_ptr, statements, true, level,
global, caches, lib, level, scope, this_ptr, statements, true,
),
// If statement
@ -352,7 +352,7 @@ impl Engine {
let (expr, if_block, else_block) = &**x;
let guard_val = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, expr.position())
@ -362,11 +362,11 @@ impl Engine {
match guard_val {
Ok(true) if if_block.is_empty() => Ok(Dynamic::UNIT),
Ok(true) => self.eval_stmt_block(
scope, global, caches, lib, this_ptr, if_block, true, level,
global, caches, lib, level, scope, this_ptr, if_block, true,
),
Ok(false) if else_block.is_empty() => Ok(Dynamic::UNIT),
Ok(false) => self.eval_stmt_block(
scope, global, caches, lib, this_ptr, else_block, true, level,
global, caches, lib, level, scope, this_ptr, else_block, true,
),
err => err.map(Into::into),
}
@ -385,7 +385,7 @@ impl Engine {
) = &**x;
let value_result =
self.eval_expr(scope, global, caches, lib, this_ptr, expr, level);
self.eval_expr(global, caches, lib, level, scope, this_ptr, expr);
if let Ok(value) = value_result {
let expr_result = if value.is_hashable() {
@ -405,7 +405,7 @@ impl Engine {
let cond_result = match block.condition {
Expr::BoolConstant(b, ..) => Ok(b),
ref c => self
.eval_expr(scope, global, caches, lib, this_ptr, c, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, c)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(
@ -436,7 +436,7 @@ impl Engine {
let cond_result = match block.condition {
Expr::BoolConstant(b, ..) => Ok(b),
ref c => self
.eval_expr(scope, global, caches, lib, this_ptr, c, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, c)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(
@ -466,12 +466,12 @@ impl Engine {
};
if let Ok(Some(expr)) = expr_result {
self.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
self.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
} else if let Ok(None) = expr_result {
// Default match clause
def_case.as_ref().map_or(Ok(Dynamic::UNIT), |&index| {
let def_expr = &expressions[index].expr;
self.eval_expr(scope, global, caches, lib, this_ptr, def_expr, level)
self.eval_expr(global, caches, lib, level, scope, this_ptr, def_expr)
})
} else {
expr_result.map(|_| Dynamic::UNIT)
@ -492,7 +492,7 @@ impl Engine {
} else {
loop {
match self.eval_stmt_block(
scope, global, caches, lib, this_ptr, body, true, level,
global, caches, lib, level, scope, this_ptr, body, true,
) {
Ok(_) => (),
Err(err) => match *err {
@ -511,7 +511,7 @@ impl Engine {
loop {
let condition = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, expr.position())
@ -523,7 +523,7 @@ impl Engine {
Ok(true) if body.is_empty() => (),
Ok(true) => {
match self.eval_stmt_block(
scope, global, caches, lib, this_ptr, body, true, level,
global, caches, lib, level, scope, this_ptr, body, true,
) {
Ok(_) => (),
Err(err) => match *err {
@ -546,7 +546,7 @@ impl Engine {
loop {
if !body.is_empty() {
match self.eval_stmt_block(
scope, global, caches, lib, this_ptr, body, true, level,
global, caches, lib, level, scope, this_ptr, body, true,
) {
Ok(_) => (),
Err(err) => match *err {
@ -558,7 +558,7 @@ impl Engine {
}
let condition = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| {
v.as_bool().map_err(|typ| {
self.make_type_mismatch_err::<bool>(typ, expr.position())
@ -578,7 +578,7 @@ impl Engine {
let (var_name, counter, expr, statements) = &**x;
let iter_result = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.map(Dynamic::flatten);
if let Ok(iter_obj) = iter_result {
@ -652,7 +652,7 @@ impl Engine {
}
self.eval_stmt_block(
scope, global, caches, lib, this_ptr, statements, true, level,
global, caches, lib, level, scope, this_ptr, statements, true,
)
.map(|_| Dynamic::UNIT)
.or_else(|err| match *err {
@ -681,7 +681,7 @@ impl Engine {
let is_break = options.contains(ASTFlags::BREAK);
if let Some(ref expr) = expr {
self.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
self.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| ERR::LoopBreak(is_break, v, *pos).into())
} else {
Err(ERR::LoopBreak(is_break, Dynamic::UNIT, *pos).into())
@ -700,7 +700,7 @@ impl Engine {
} = &**x;
let result = self
.eval_stmt_block(scope, global, caches, lib, this_ptr, try_block, true, level)
.eval_stmt_block(global, caches, lib, level, scope, this_ptr, try_block, true)
.map(|_| Dynamic::UNIT);
match result {
@ -750,14 +750,14 @@ impl Engine {
}
let result = self.eval_stmt_block(
scope,
global,
caches,
lib,
level,
scope,
this_ptr,
catch_block,
true,
level,
);
scope.rewind(orig_scope_len);
@ -779,7 +779,7 @@ impl Engine {
// Throw value
Stmt::Return(Some(expr), options, pos) if options.contains(ASTFlags::BREAK) => self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| Err(ERR::ErrorRuntime(v.flatten(), *pos).into())),
// Empty throw
@ -789,7 +789,7 @@ impl Engine {
// Return value
Stmt::Return(Some(expr), .., pos) => self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| Err(ERR::Return(v.flatten(), *pos).into())),
// Empty return
@ -821,7 +821,7 @@ impl Engine {
nesting_level,
will_shadow,
};
let context = EvalContext::new(self, scope, global, None, lib, this_ptr, level);
let context = EvalContext::new(self, global, None, lib, level, scope, this_ptr);
match filter(true, info, context) {
Ok(true) => None,
@ -841,7 +841,7 @@ impl Engine {
} else {
// Evaluate initial value
let value_result = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.map(Dynamic::flatten);
if let Ok(mut value) = value_result {
@ -904,7 +904,7 @@ impl Engine {
}
let path_result = self
.eval_expr(scope, global, caches, lib, this_ptr, expr, level)
.eval_expr(global, caches, lib, level, scope, this_ptr, expr)
.and_then(|v| {
let typ = v.type_name();
v.try_cast::<crate::ImmutableString>().ok_or_else(|| {
@ -1016,15 +1016,15 @@ impl Engine {
#[inline]
pub(crate) fn eval_global_statements(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
statements: &[Stmt],
lib: &[&Module],
level: usize,
scope: &mut Scope,
statements: &[Stmt],
) -> RhaiResult {
self.eval_stmt_block(
scope, global, caches, lib, &mut None, statements, false, level,
global, caches, lib, level, scope, &mut None, statements, false,
)
.or_else(|err| match *err {
ERR::Return(out, ..) => Ok(out),

120
src/func/call.rs
View File

@ -326,13 +326,13 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
name: &str,
op_token: Option<&Token>,
hash: u64,
args: &mut FnCallArgs,
is_ref_mut: bool,
pos: Position,
level: usize,
) -> RhaiResultOf<(Dynamic, bool)> {
self.track_operation(global, pos)?;
@ -416,7 +416,9 @@ impl Engine {
Ok(ref r) => crate::eval::DebuggerEvent::FunctionExitWithValue(r),
Err(ref err) => crate::eval::DebuggerEvent::FunctionExitWithError(err),
};
match self.run_debugger_raw(scope, global, lib, &mut None, node, event, level) {
match self
.run_debugger_raw(global, caches, lib, level, scope, &mut None, node, event)
{
Ok(_) => (),
Err(err) => _result = Err(err),
}
@ -536,10 +538,11 @@ impl Engine {
/// all others are silently replaced by `()`!
pub(crate) fn exec_fn_call(
&self,
_scope: Option<&mut Scope>,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
_scope: Option<&mut Scope>,
fn_name: &str,
op_token: Option<&Token>,
hashes: FnCallHashes,
@ -547,7 +550,6 @@ impl Engine {
is_ref_mut: bool,
_is_method_call: bool,
pos: Position,
level: usize,
) -> RhaiResultOf<(Dynamic, bool)> {
fn no_method_err(name: &str, pos: Position) -> RhaiResultOf<(Dynamic, bool)> {
Err(ERR::ErrorRuntime(
@ -654,16 +656,16 @@ impl Engine {
let (first_arg, rest_args) = args.split_first_mut().unwrap();
self.call_script_fn(
scope,
global,
caches,
lib,
level,
scope,
&mut Some(*first_arg),
func,
rest_args,
true,
pos,
level,
)
} else {
// Normal call of script function
@ -675,7 +677,7 @@ impl Engine {
}
let result = self.call_script_fn(
scope, global, caches, lib, &mut None, func, args, true, pos, level,
global, caches, lib, level, scope, &mut None, func, args, true, pos,
);
// Restore the original reference
@ -695,7 +697,7 @@ impl Engine {
let hash = hashes.native();
self.exec_native_fn_call(
global, caches, lib, fn_name, op_token, hash, args, is_ref_mut, pos, level,
global, caches, lib, level, fn_name, op_token, hash, args, is_ref_mut, pos,
)
}
@ -703,20 +705,20 @@ impl Engine {
#[inline]
pub(crate) fn get_arg_value(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
arg_expr: &Expr,
level: usize,
) -> RhaiResultOf<(Dynamic, Position)> {
// Literal values
if let Some(value) = arg_expr.get_literal_value() {
self.track_operation(global, arg_expr.start_position())?;
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, arg_expr, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, arg_expr)?;
return Ok((value, arg_expr.start_position()));
}
@ -727,7 +729,7 @@ impl Engine {
matches!(status, crate::eval::DebuggerStatus::FunctionExit(..))
});
let result = self.eval_expr(scope, global, caches, lib, this_ptr, arg_expr, level);
let result = self.eval_expr(global, caches, lib, level, scope, this_ptr, arg_expr);
// Restore function exit status
#[cfg(feature = "debugging")]
@ -743,13 +745,13 @@ impl Engine {
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
fn_name: &str,
mut hash: FnCallHashes,
target: &mut crate::eval::Target,
mut call_args: &mut [Dynamic],
first_arg_pos: Position,
fn_call_pos: Position,
level: usize,
) -> RhaiResultOf<(Dynamic, bool)> {
let is_ref_mut = target.is_ref();
@ -781,10 +783,11 @@ impl Engine {
// Map it to name(args) in function-call style
self.exec_fn_call(
None,
global,
caches,
lib,
level,
None,
fn_name,
None,
new_hash,
@ -792,7 +795,6 @@ impl Engine {
false,
false,
fn_call_pos,
level,
)
}
KEYWORD_FN_PTR_CALL => {
@ -837,10 +839,11 @@ impl Engine {
// Map it to name(args) in function-call style
self.exec_fn_call(
None,
global,
caches,
lib,
level,
None,
&fn_name,
None,
new_hash,
@ -848,7 +851,6 @@ impl Engine {
is_ref_mut,
true,
fn_call_pos,
level,
)
}
KEYWORD_FN_PTR_CURRY => {
@ -938,10 +940,11 @@ impl Engine {
args.extend(call_args.iter_mut());
self.exec_fn_call(
None,
global,
caches,
lib,
level,
None,
fn_name,
None,
hash,
@ -949,7 +952,6 @@ impl Engine {
is_ref_mut,
true,
fn_call_pos,
level,
)
}
}?;
@ -965,10 +967,11 @@ impl Engine {
/// Call a function in normal function-call style.
pub(crate) fn make_function_call(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
fn_name: &str,
op_token: Option<&Token>,
@ -977,7 +980,6 @@ impl Engine {
hashes: FnCallHashes,
capture_scope: bool,
pos: Position,
level: usize,
) -> RhaiResult {
let mut first_arg = first_arg;
let mut a_expr = args_expr;
@ -994,7 +996,7 @@ impl Engine {
KEYWORD_FN_PTR_CALL if total_args >= 1 => {
let arg = first_arg.unwrap();
let (arg_value, arg_pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, arg, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, arg)?;
if !arg_value.is::<FnPtr>() {
let typ = self.map_type_name(arg_value.type_name());
@ -1035,7 +1037,7 @@ impl Engine {
KEYWORD_FN_PTR if total_args == 1 => {
let arg = first_arg.unwrap();
let (arg_value, arg_pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, arg, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, arg)?;
// Fn - only in function call style
return arg_value
@ -1050,7 +1052,7 @@ impl Engine {
KEYWORD_FN_PTR_CURRY if total_args > 1 => {
let first = first_arg.unwrap();
let (arg_value, arg_pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, first, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, first)?;
if !arg_value.is::<FnPtr>() {
let typ = self.map_type_name(arg_value.type_name());
@ -1062,7 +1064,7 @@ impl Engine {
// Append the new curried arguments to the existing list.
let fn_curry = a_expr.iter().try_fold(fn_curry, |mut curried, expr| {
let (value, ..) =
self.get_arg_value(scope, global, caches, lib, this_ptr, expr, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, expr)?;
curried.push(value);
Ok::<_, RhaiError>(curried)
})?;
@ -1075,7 +1077,7 @@ impl Engine {
crate::engine::KEYWORD_IS_SHARED if total_args == 1 => {
let arg = first_arg.unwrap();
let (arg_value, ..) =
self.get_arg_value(scope, global, caches, lib, this_ptr, arg, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, arg)?;
return Ok(arg_value.is_shared().into());
}
@ -1084,14 +1086,14 @@ impl Engine {
crate::engine::KEYWORD_IS_DEF_FN if total_args == 2 => {
let first = first_arg.unwrap();
let (arg_value, arg_pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, first, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, first)?;
let fn_name = arg_value
.into_immutable_string()
.map_err(|typ| self.make_type_mismatch_err::<ImmutableString>(typ, arg_pos))?;
let (arg_value, arg_pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, &a_expr[0], level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, &a_expr[0])?;
let num_params = arg_value
.as_int()
@ -1110,7 +1112,7 @@ impl Engine {
KEYWORD_IS_DEF_VAR if total_args == 1 => {
let arg = first_arg.unwrap();
let (arg_value, arg_pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, arg, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, arg)?;
let var_name = arg_value
.into_immutable_string()
.map_err(|typ| self.make_type_mismatch_err::<ImmutableString>(typ, arg_pos))?;
@ -1125,12 +1127,12 @@ impl Engine {
let orig_imports_len = global.num_imports();
let arg = first_arg.unwrap();
let (arg_value, pos) =
self.get_arg_value(scope, global, caches, lib, this_ptr, arg, level)?;
self.get_arg_value(global, caches, lib, level, scope, this_ptr, arg)?;
let s = &arg_value
.into_immutable_string()
.map_err(|typ| self.make_type_mismatch_err::<ImmutableString>(typ, pos))?;
let result =
self.eval_script_expr_in_place(scope, global, caches, lib, s, pos, level + 1);
self.eval_script_expr_in_place(global, caches, lib, level + 1, scope, s, pos);
// IMPORTANT! If the eval defines new variables in the current scope,
// all variable offsets from this point on will be mis-aligned.
@ -1172,7 +1174,7 @@ impl Engine {
.copied()
.chain(a_expr.iter())
.try_for_each(|expr| {
self.get_arg_value(scope, global, caches, lib, this_ptr, expr, level)
self.get_arg_value(global, caches, lib, level, scope, this_ptr, expr)
.map(|(value, ..)| arg_values.push(value.flatten()))
})?;
args.extend(curry.iter_mut());
@ -1183,8 +1185,8 @@ impl Engine {
return self
.exec_fn_call(
scope, global, caches, lib, name, op_token, hashes, &mut args, is_ref_mut,
false, pos, level,
global, caches, lib, level, scope, name, op_token, hashes, &mut args,
is_ref_mut, false, pos,
)
.map(|(v, ..)| v);
}
@ -1200,16 +1202,16 @@ impl Engine {
let first_expr = first_arg.unwrap();
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, first_expr, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, first_expr)?;
// func(x, ...) -> x.func(...)
a_expr.iter().try_for_each(|expr| {
self.get_arg_value(scope, global, caches, lib, this_ptr, expr, level)
self.get_arg_value(global, caches, lib, level, scope, this_ptr, expr)
.map(|(value, ..)| arg_values.push(value.flatten()))
})?;
let (mut target, _pos) =
self.search_namespace(scope, global, lib, this_ptr, first_expr, level)?;
self.search_namespace(global, caches, lib, level, scope, this_ptr, first_expr)?;
if target.is_read_only() {
target = target.into_owned();
@ -1236,7 +1238,7 @@ impl Engine {
.into_iter()
.chain(a_expr.iter())
.try_for_each(|expr| {
self.get_arg_value(scope, global, caches, lib, this_ptr, expr, level)
self.get_arg_value(global, caches, lib, level, scope, this_ptr, expr)
.map(|(value, ..)| arg_values.push(value.flatten()))
})?;
args.extend(curry.iter_mut());
@ -1246,8 +1248,8 @@ impl Engine {
}
self.exec_fn_call(
None, global, caches, lib, name, op_token, hashes, &mut args, is_ref_mut, false, pos,
level,
global, caches, lib, level, None, name, op_token, hashes, &mut args, is_ref_mut, false,
pos,
)
.map(|(v, ..)| v)
}
@ -1256,17 +1258,17 @@ impl Engine {
#[cfg(not(feature = "no_module"))]
pub(crate) fn make_qualified_function_call(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
namespace: &crate::ast::Namespace,
fn_name: &str,
args_expr: &[Expr],
hash: u64,
pos: Position,
level: usize,
) -> RhaiResult {
let mut arg_values = FnArgsVec::with_capacity(args_expr.len());
let mut args = FnArgsVec::with_capacity(args_expr.len());
@ -1280,20 +1282,20 @@ impl Engine {
// and avoid cloning the value
if !args_expr.is_empty() && args_expr[0].is_variable_access(true) {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, lib, this_ptr, &args_expr[0], level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, &args_expr[0])?;
// func(x, ...) -> x.func(...)
arg_values.push(Dynamic::UNIT);
args_expr.iter().skip(1).try_for_each(|expr| {
self.get_arg_value(scope, global, caches, lib, this_ptr, expr, level)
self.get_arg_value(global, caches, lib, level, scope, this_ptr, expr)
.map(|(value, ..)| arg_values.push(value.flatten()))
})?;
// Get target reference to first argument
let first_arg = &args_expr[0];
let (target, _pos) =
self.search_scope_only(scope, global, lib, this_ptr, first_arg, level)?;
self.search_scope_only(global, caches, lib, level, scope, this_ptr, first_arg)?;
self.track_operation(global, _pos)?;
@ -1316,7 +1318,7 @@ impl Engine {
} else {
// func(..., ...) or func(mod::x, ...)
args_expr.iter().try_for_each(|expr| {
self.get_arg_value(scope, global, caches, lib, this_ptr, expr, level)
self.get_arg_value(global, caches, lib, level, scope, this_ptr, expr)
.map(|(value, ..)| arg_values.push(value.flatten()))
})?;
args.extend(arg_values.iter_mut());
@ -1393,7 +1395,7 @@ impl Engine {
let orig_source = mem::replace(&mut global.source, module.id_raw().cloned());
let result = self.call_script_fn(
new_scope, global, caches, lib, &mut None, fn_def, &mut args, true, pos, level,
global, caches, lib, level, new_scope, &mut None, fn_def, &mut args, true, pos,
);
global.source = orig_source;
@ -1440,13 +1442,13 @@ impl Engine {
/// Evaluate a text script in place - used primarily for 'eval'.
pub(crate) fn eval_script_expr_in_place(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
script: &str,
_pos: Position,
level: usize,
) -> RhaiResult {
self.track_operation(global, _pos)?;
@ -1479,20 +1481,20 @@ impl Engine {
}
// Evaluate the AST
self.eval_global_statements(scope, global, caches, statements, lib, level)
self.eval_global_statements(global, caches, lib, level, scope, statements)
}
/// Evaluate a function call expression.
pub(crate) fn eval_fn_call_expr(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
expr: &FnCallExpr,
pos: Position,
level: usize,
) -> RhaiResult {
let FnCallExpr {
#[cfg(not(feature = "no_module"))]
@ -1510,12 +1512,12 @@ impl Engine {
// Short-circuit native binary operator call if under Fast Operators mode
if op_token.is_some() && self.fast_operators() && args.len() == 2 {
let mut lhs = self
.get_arg_value(scope, global, caches, lib, this_ptr, &args[0], level)?
.get_arg_value(global, caches, lib, level, scope, this_ptr, &args[0])?
.0
.flatten();
let mut rhs = self
.get_arg_value(scope, global, caches, lib, this_ptr, &args[1], level)?
.get_arg_value(global, caches, lib, level, scope, this_ptr, &args[1])?
.0
.flatten();
@ -1531,8 +1533,8 @@ impl Engine {
return self
.exec_fn_call(
None, global, caches, lib, name, op_token, *hashes, operands, false, false,
pos, level,
global, caches, lib, level, None, name, op_token, *hashes, operands, false,
false, pos,
)
.map(|(v, ..)| v);
}
@ -1543,7 +1545,7 @@ impl Engine {
let hash = hashes.native();
return self.make_qualified_function_call(
scope, global, caches, lib, this_ptr, namespace, name, args, hash, pos, level,
global, caches, lib, level, scope, this_ptr, namespace, name, args, hash, pos,
);
}
@ -1554,8 +1556,8 @@ impl Engine {
);
self.make_function_call(
scope, global, caches, lib, this_ptr, name, op_token, first_arg, args, *hashes,
*capture, pos, level,
global, caches, lib, level, scope, this_ptr, name, op_token, first_arg, args, *hashes,
*capture, pos,
)
}
}

6
src/func/native.rs
View File

@ -393,13 +393,13 @@ impl<'a> NativeCallContext<'a> {
global,
caches,
self.lib,
self.level + 1,
fn_name,
op_token,
calc_fn_hash(None, fn_name, args_len),
args,
is_ref_mut,
Position::NONE,
self.level + 1,
)
.map(|(r, ..)| r);
}
@ -418,10 +418,11 @@ impl<'a> NativeCallContext<'a> {
self.engine()
.exec_fn_call(
None,
global,
caches,
self.lib,
self.level + 1,
None,
fn_name,
op_token,
hash,
@ -429,7 +430,6 @@ impl<'a> NativeCallContext<'a> {
is_ref_mut,
is_method_call,
Position::NONE,
self.level + 1,
)
.map(|(r, ..)| r)
}

14
src/func/script.rs
View File

@ -24,16 +24,16 @@ impl Engine {
/// **DO NOT** reuse the argument values unless for the first `&mut` argument - all others are silently replaced by `()`!
pub(crate) fn call_script_fn(
&self,
scope: &mut Scope,
global: &mut GlobalRuntimeState,
caches: &mut Caches,
lib: &[&Module],
level: usize,
scope: &mut Scope,
this_ptr: &mut Option<&mut Dynamic>,
fn_def: &ScriptFnDef,
args: &mut FnCallArgs,
rewind_scope: bool,
pos: Position,
level: usize,
) -> RhaiResult {
#[cold]
#[inline(never)]
@ -140,20 +140,20 @@ impl Engine {
#[cfg(feature = "debugging")]
{
let node = crate::ast::Stmt::Noop(fn_def.body.position());
self.run_debugger(scope, global, lib, this_ptr, &node, level)?;
self.run_debugger(global, caches, lib, level, scope, this_ptr, &node)?;
}
// Evaluate the function
let mut _result = self
.eval_stmt_block(
scope,
global,
caches,
lib,
level,
scope,
this_ptr,
&fn_def.body,
rewind_scope,
level,
)
.or_else(|err| match *err {
// Convert return statement to return value
@ -190,7 +190,9 @@ impl Engine {
Ok(ref r) => crate::eval::DebuggerEvent::FunctionExitWithValue(r),
Err(ref err) => crate::eval::DebuggerEvent::FunctionExitWithError(err),
};
match self.run_debugger_raw(scope, global, lib, this_ptr, node, event, level) {
match self
.run_debugger_raw(global, caches, lib, level, scope, this_ptr, node, event)
{
Ok(_) => (),
Err(err) => _result = Err(err),
}

5
src/module/mod.rs
View File

@ -3,6 +3,7 @@
#[cfg(feature = "metadata")]
use crate::api::type_names::format_type;
use crate::ast::FnAccess;
use crate::eval::Caches;
use crate::func::{
shared_take_or_clone, CallableFunction, FnCallArgs, IteratorFn, RegisterNativeFunction,
SendSync,
@ -1984,7 +1985,9 @@ impl Module {
let orig_constants = std::mem::take(&mut global.constants);
// Run the script
let result = engine.eval_ast_with_scope_raw(&mut scope, global, ast, 0);
let caches = &mut Caches::new();
let result = engine.eval_ast_with_scope_raw(global, caches, 0, &mut scope, ast);
// Create new module
let mut module = Module::new();

2
src/optimizer.rs
View File

@ -152,13 +152,13 @@ impl<'a> OptimizerState<'a> {
&mut self.global,
&mut self.caches,
lib,
0,
fn_name,
op_token,
calc_fn_hash(None, fn_name, arg_values.len()),
&mut arg_values.iter_mut().collect::<StaticVec<_>>(),
false,
Position::NONE,
0,
)
.ok()
.map(|(v, ..)| v)

4
src/parser.rs
View File

@ -2909,12 +2909,12 @@ impl Engine {
let mut this_ptr = None;
let context = EvalContext::new(
self,
&mut state.stack,
&mut state.global,
None,
&[],
&mut this_ptr,
level,
&mut state.stack,
&mut this_ptr,
);
match filter(false, info, context) {