From 6053aa164158bb95686d3403cb51743fc794f7be Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Tue, 8 Nov 2022 15:01:40 +0800 Subject: [PATCH] Clean up types. --- src/api/call_fn.rs | 8 +- src/api/eval.rs | 8 +- src/api/register.rs | 11 ++- src/api/run.rs | 8 +- src/ast/ast.rs | 22 ++--- src/ast/script_fn.rs | 4 +- src/engine.rs | 7 +- src/eval/chaining.rs | 26 +++--- src/eval/debugger.rs | 13 ++- src/eval/eval_context.rs | 23 ++--- src/eval/expr.rs | 23 +++-- src/eval/global_state.rs | 24 +++-- src/eval/stmt.rs | 144 ++++++++++++++--------------- src/func/call.rs | 36 ++++---- src/func/native.rs | 22 ++--- src/func/script.rs | 10 +- src/lib.rs | 3 + src/module/mod.rs | 10 +- src/module/resolvers/collection.rs | 4 +- src/module/resolvers/dummy.rs | 4 +- src/module/resolvers/file.rs | 13 +-- src/module/resolvers/mod.rs | 6 +- src/module/resolvers/stat.rs | 23 ++--- src/optimizer.rs | 6 +- src/packages/mod.rs | 4 +- src/parser.rs | 10 +- src/types/fn_ptr.rs | 6 +- src/types/restore.rs | 18 +++- 28 files changed, 248 insertions(+), 248 deletions(-) diff --git a/src/api/call_fn.rs b/src/api/call_fn.rs index 2057d9b7..b467e54d 100644 --- a/src/api/call_fn.rs +++ b/src/api/call_fn.rs @@ -5,8 +5,8 @@ use crate::eval::{Caches, GlobalRuntimeState}; use crate::types::dynamic::Variant; use crate::types::RestoreOnDrop; use crate::{ - reify, Dynamic, Engine, FuncArgs, Position, RhaiResult, RhaiResultOf, Scope, Shared, StaticVec, - AST, ERR, + reify, Dynamic, Engine, FuncArgs, Position, RhaiResult, RhaiResultOf, Scope, SharedModule, + StaticVec, AST, ERR, }; use std::any::{type_name, TypeId}; #[cfg(feature = "no_std")] @@ -249,7 +249,7 @@ impl Engine { arg_values: &mut [Dynamic], ) -> RhaiResult { let statements = ast.statements(); - let lib = &[AsRef::>::as_ref(ast).clone()]; + let lib = &[AsRef::::as_ref(ast).clone()]; let mut this_ptr = this_ptr; let orig_scope_len = scope.len(); @@ -260,7 +260,7 @@ impl Engine { ast.resolver().cloned(), ); #[cfg(not(feature = "no_module"))] - let global = &mut *RestoreOnDrop::new(global, move |g| { + let global = &mut *RestoreOnDrop::lock(global, move |g| { g.embedded_module_resolver = orig_embedded_module_resolver }); diff --git a/src/api/eval.rs b/src/api/eval.rs index 294bf89a..28bcdcbd 100644 --- a/src/api/eval.rs +++ b/src/api/eval.rs @@ -196,7 +196,7 @@ impl Engine { global.debugger.status = crate::eval::DebuggerStatus::Terminate; let lib = &[ #[cfg(not(feature = "no_function"))] - AsRef::>::as_ref(ast).clone(), + AsRef::::as_ref(ast).clone(), ]; let node = &crate::ast::Stmt::Noop(Position::NONE); self.run_debugger(global, caches, lib, 0, scope, &mut None, node)?; @@ -227,7 +227,7 @@ impl Engine { ast.resolver().cloned(), ); #[cfg(not(feature = "no_module"))] - let global = &mut *RestoreOnDrop::new(global, move |g| { + let global = &mut *RestoreOnDrop::lock(global, move |g| { g.embedded_module_resolver = orig_embedded_module_resolver }); @@ -239,7 +239,7 @@ impl Engine { let lib = &[ #[cfg(not(feature = "no_function"))] - AsRef::>::as_ref(ast).clone(), + AsRef::::as_ref(ast).clone(), ]; self.eval_global_statements(global, caches, lib, level, scope, statements) @@ -258,7 +258,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[crate::Shared], + lib: &[crate::SharedModule], level: usize, scope: &mut Scope, statements: &[crate::ast::Stmt], diff --git a/src/api/register.rs b/src/api/register.rs index ce5c0c4a..9e2f7490 100644 --- a/src/api/register.rs +++ b/src/api/register.rs @@ -4,6 +4,7 @@ use crate::func::{FnCallArgs, RegisterNativeFunction, SendSync}; use crate::types::dynamic::Variant; use crate::{ Engine, FnAccess, FnNamespace, Identifier, Module, NativeCallContext, RhaiResultOf, Shared, + SharedModule, }; use std::any::{type_name, TypeId}; #[cfg(feature = "no_std")] @@ -636,7 +637,7 @@ impl Engine { /// When searching for functions, modules loaded later are preferred. In other words, loaded /// modules are searched in reverse order. #[inline(always)] - pub fn register_global_module(&mut self, module: Shared) -> &mut Self { + pub fn register_global_module(&mut self, module: SharedModule) -> &mut Self { // Insert the module into the front. // The first module is always the global namespace. self.global_modules.insert(1, module); @@ -661,7 +662,7 @@ impl Engine { /// let mut module = Module::new(); /// module.set_native_fn("calc", |x: i64| Ok(x + 1)); /// - /// let module: Shared = module.into(); + /// let module: SharedModule = module.into(); /// /// engine /// // Register the module as a fixed sub-module @@ -680,12 +681,12 @@ impl Engine { pub fn register_static_module( &mut self, name: impl AsRef, - module: Shared, + module: SharedModule, ) -> &mut Self { fn register_static_module_raw( - root: &mut std::collections::BTreeMap>, + root: &mut std::collections::BTreeMap, name: &str, - module: Shared, + module: SharedModule, ) { let separator = crate::tokenizer::Token::DoubleColon.syntax(); let separator = separator.as_ref(); diff --git a/src/api/run.rs b/src/api/run.rs index 34f1d106..90c6abf2 100644 --- a/src/api/run.rs +++ b/src/api/run.rs @@ -2,7 +2,7 @@ use crate::eval::{Caches, GlobalRuntimeState}; use crate::parser::ParseState; -use crate::{Engine, RhaiResultOf, Scope, AST}; +use crate::{Engine, RhaiResultOf, Scope, SharedModule, AST}; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -122,9 +122,9 @@ impl Engine { let statements = ast.statements(); if !statements.is_empty() { - let lib: &[crate::Shared] = &[ + let lib: &[SharedModule] = &[ #[cfg(not(feature = "no_function"))] - AsRef::>::as_ref(ast).clone(), + AsRef::::as_ref(ast).clone(), ]; let lib = if lib.first().map_or(true, |m| m.is_empty()) { &[][..] @@ -139,7 +139,7 @@ impl Engine { global.debugger.status = crate::eval::DebuggerStatus::Terminate; let lib = &[ #[cfg(not(feature = "no_function"))] - AsRef::>::as_ref(ast).clone(), + AsRef::::as_ref(ast).clone(), ]; let node = &crate::ast::Stmt::Noop(crate::Position::NONE); self.run_debugger(global, caches, lib, 0, scope, &mut None, node)?; diff --git a/src/ast/ast.rs b/src/ast/ast.rs index 9c186e67..76277e7b 100644 --- a/src/ast/ast.rs +++ b/src/ast/ast.rs @@ -28,7 +28,7 @@ pub struct AST { body: StmtBlock, /// Script-defined functions. #[cfg(not(feature = "no_function"))] - lib: crate::Shared, + lib: crate::SharedModule, /// Embedded module resolver, if any. #[cfg(not(feature = "no_module"))] resolver: Option>, @@ -74,7 +74,7 @@ impl AST { #[must_use] pub(crate) fn new( statements: impl IntoIterator, - #[cfg(not(feature = "no_function"))] functions: impl Into>, + #[cfg(not(feature = "no_function"))] functions: impl Into, ) -> Self { Self { source: None, @@ -94,7 +94,7 @@ impl AST { #[must_use] pub fn new( statements: impl IntoIterator, - #[cfg(not(feature = "no_function"))] functions: impl Into>, + #[cfg(not(feature = "no_function"))] functions: impl Into, ) -> Self { Self { source: None, @@ -113,7 +113,7 @@ impl AST { #[must_use] pub(crate) fn new_with_source( statements: impl IntoIterator, - #[cfg(not(feature = "no_function"))] functions: impl Into>, + #[cfg(not(feature = "no_function"))] functions: impl Into, source: impl Into, ) -> Self { let mut ast = Self::new( @@ -131,7 +131,7 @@ impl AST { #[must_use] pub fn new_with_source( statements: impl IntoIterator, - #[cfg(not(feature = "no_function"))] functions: impl Into>, + #[cfg(not(feature = "no_function"))] functions: impl Into, source: impl Into, ) -> Self { let mut ast = Self::new( @@ -267,7 +267,7 @@ impl AST { #[cfg(not(feature = "no_function"))] #[inline(always)] #[must_use] - pub(crate) const fn shared_lib(&self) -> &crate::Shared { + pub(crate) const fn shared_lib(&self) -> &SharedModule { &self.lib } /// _(internals)_ Get the internal shared [`Module`][crate::Module] containing all script-defined functions. @@ -278,7 +278,7 @@ impl AST { #[cfg(not(feature = "no_function"))] #[inline(always)] #[must_use] - pub const fn shared_lib(&self) -> &crate::Shared { + pub const fn shared_lib(&self) -> &crate::SharedModule { &self.lib } /// Get the embedded [module resolver][crate::ModuleResolver]. @@ -957,19 +957,19 @@ impl AsRef for AST { } #[cfg(not(feature = "no_function"))] -impl Borrow> for AST { +impl Borrow for AST { #[inline(always)] #[must_use] - fn borrow(&self) -> &crate::Shared { + fn borrow(&self) -> &crate::SharedModule { self.shared_lib() } } #[cfg(not(feature = "no_function"))] -impl AsRef> for AST { +impl AsRef for AST { #[inline(always)] #[must_use] - fn as_ref(&self) -> &crate::Shared { + fn as_ref(&self) -> &crate::SharedModule { self.shared_lib() } } diff --git a/src/ast/script_fn.rs b/src/ast/script_fn.rs index d40d6a5a..743bf2f5 100644 --- a/src/ast/script_fn.rs +++ b/src/ast/script_fn.rs @@ -20,9 +20,9 @@ use std::{fmt, hash::Hash}; #[derive(Debug, Clone)] pub struct EncapsulatedEnviron { /// Functions defined within the same [`AST`][crate::AST]. - pub lib: crate::Shared, + pub lib: crate::SharedModule, /// Imported [modules][crate::Module]. - pub imports: Box<[(ImmutableString, crate::Shared)]>, + pub imports: Box<[(ImmutableString, crate::SharedModule)]>, /// Globally-defined constants. pub constants: Option, } diff --git a/src/engine.rs b/src/engine.rs index 0afadf75..8d5df823 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -9,7 +9,8 @@ use crate::packages::{Package, StandardPackage}; use crate::tokenizer::Token; use crate::types::StringsInterner; use crate::{ - Dynamic, Identifier, ImmutableString, Locked, Module, OptimizationLevel, Shared, StaticVec, + Dynamic, Identifier, ImmutableString, Locked, Module, OptimizationLevel, SharedModule, + StaticVec, }; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -91,10 +92,10 @@ pub const OP_INCLUSIVE_RANGE: &str = Token::InclusiveRange.literal_syntax(); /// ``` pub struct Engine { /// A collection of all modules loaded into the global namespace of the Engine. - pub(crate) global_modules: StaticVec>, + pub(crate) global_modules: StaticVec, /// A collection of all sub-modules directly loaded into the Engine. #[cfg(not(feature = "no_module"))] - pub(crate) global_sub_modules: std::collections::BTreeMap>, + pub(crate) global_sub_modules: std::collections::BTreeMap, /// A module resolution service. #[cfg(not(feature = "no_module"))] diff --git a/src/eval/chaining.rs b/src/eval/chaining.rs index 7d7560fc..021dfdc3 100644 --- a/src/eval/chaining.rs +++ b/src/eval/chaining.rs @@ -6,7 +6,7 @@ use crate::ast::{ASTFlags, Expr, OpAssignment}; use crate::types::dynamic::Union; use crate::types::RestoreOnDrop; use crate::{ - Dynamic, Engine, FnArgsVec, Module, Position, RhaiResult, RhaiResultOf, Scope, Shared, ERR, + Dynamic, Engine, FnArgsVec, Position, RhaiResult, RhaiResultOf, Scope, SharedModule, ERR, }; use std::hash::Hash; #[cfg(feature = "no_std")] @@ -43,7 +43,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, this_ptr: &mut Option<&mut Dynamic>, target: &mut Target, @@ -205,7 +205,7 @@ impl Engine { global, caches, lib, level, scope, this_ptr, rhs, )?; #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| { + let global = &mut *RestoreOnDrop::lock(global, move |g| { g.debugger.reset_status(reset) }); @@ -216,7 +216,7 @@ impl Engine { // Truncate the index values upon exit let offset = idx_values.len() - args.len(); let idx_values = - &mut *RestoreOnDrop::new(idx_values, move |v| v.truncate(offset)); + &mut *RestoreOnDrop::lock(idx_values, move |v| v.truncate(offset)); let call_args = &mut idx_values[offset..]; let pos1 = args.get(0).map_or(Position::NONE, Expr::position); @@ -384,7 +384,7 @@ impl Engine { global, caches, lib, level, scope, this_ptr, _node, )?; #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| { + let global = &mut *RestoreOnDrop::lock(global, move |g| { g.debugger.reset_status(reset) }); @@ -394,7 +394,7 @@ impl Engine { // Truncate the index values upon exit let offset = idx_values.len() - args.len(); - let idx_values = &mut *RestoreOnDrop::new(idx_values, move |v| { + let idx_values = &mut *RestoreOnDrop::lock(idx_values, move |v| { v.truncate(offset) }); @@ -516,7 +516,7 @@ impl Engine { global, caches, lib, level, scope, this_ptr, _node, )?; #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| { + let global = &mut *RestoreOnDrop::lock(global, move |g| { g.debugger.reset_status(reset) }); @@ -527,7 +527,7 @@ impl Engine { // Truncate the index values upon exit let offset = idx_values.len() - args.len(); let idx_values = - &mut *RestoreOnDrop::new(idx_values, move |v| { + &mut *RestoreOnDrop::lock(idx_values, move |v| { v.truncate(offset) }); @@ -570,7 +570,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -661,7 +661,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -773,7 +773,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, target: &mut Dynamic, idx: &mut Dynamic, @@ -796,7 +796,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, target: &mut Dynamic, idx: &mut Dynamic, @@ -820,7 +820,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, target: &'t mut Dynamic, idx: &mut Dynamic, diff --git a/src/eval/debugger.rs b/src/eval/debugger.rs index 3048e5bc..8c2d94e5 100644 --- a/src/eval/debugger.rs +++ b/src/eval/debugger.rs @@ -4,7 +4,7 @@ use super::{Caches, EvalContext, GlobalRuntimeState}; use crate::ast::{ASTNode, Expr, Stmt}; use crate::{ - Dynamic, Engine, EvalAltResult, ImmutableString, Module, Position, RhaiResultOf, Scope, Shared, + Dynamic, Engine, EvalAltResult, ImmutableString, Position, RhaiResultOf, Scope, SharedModule, }; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -413,7 +413,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -440,7 +440,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -463,7 +463,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -510,7 +510,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -519,8 +519,7 @@ impl Engine { ) -> Result, Box> { let src = global.source_raw().cloned(); let src = src.as_ref().map(|s| s.as_str()); - let context = - crate::EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr); + let context = crate::EvalContext::new(self, global, caches, lib, level, scope, this_ptr); if let Some((.., ref on_debugger)) = self.debugger { let command = on_debugger(context, event, node, src, node.position())?; diff --git a/src/eval/eval_context.rs b/src/eval/eval_context.rs index 99456ce1..dc50a63c 100644 --- a/src/eval/eval_context.rs +++ b/src/eval/eval_context.rs @@ -1,7 +1,7 @@ //! Evaluation context. use super::{Caches, GlobalRuntimeState}; -use crate::{Dynamic, Engine, Module, Scope, Shared}; +use crate::{Dynamic, Engine, Module, Scope, SharedModule}; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -16,9 +16,9 @@ pub struct EvalContext<'a, 's, 'ps, 'g, 'c, 't, 'pt> { /// The current [`GlobalRuntimeState`]. global: &'g mut GlobalRuntimeState, /// The current [caches][Caches], if available. - caches: Option<&'c mut Caches>, + caches: &'c mut Caches, /// The current stack of imported [modules][Module]. - lib: &'a [Shared], + lib: &'a [SharedModule], /// The current bound `this` pointer, if any. this_ptr: &'t mut Option<&'pt mut Dynamic>, /// The current nesting level of function calls. @@ -32,8 +32,8 @@ impl<'a, 's, 'ps, 'g, 'c, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'c, 't, 'pt> { pub fn new( engine: &'a Engine, global: &'g mut GlobalRuntimeState, - caches: Option<&'c mut Caches>, - lib: &'a [Shared], + caches: &'c mut Caches, + lib: &'a [SharedModule], level: usize, scope: &'s mut Scope<'ps>, this_ptr: &'t mut Option<&'pt mut Dynamic>, @@ -117,7 +117,7 @@ impl<'a, 's, 'ps, 'g, 'c, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'c, 't, 'pt> { #[cfg(feature = "internals")] #[inline(always)] #[must_use] - pub const fn namespaces(&self) -> &[Shared] { + pub const fn namespaces(&self) -> &[SharedModule] { self.lib } /// The current bound `this` pointer, if any. @@ -173,17 +173,10 @@ impl<'a, 's, 'ps, 'g, 'c, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'c, 't, 'pt> { ) -> crate::RhaiResult { let expr: &crate::ast::Expr = expr; - let mut new_caches = Caches::new(); - - let caches = match self.caches.as_mut() { - Some(c) => c, - None => &mut new_caches, - }; - match expr { crate::ast::Expr::Stmt(statements) => self.engine.eval_stmt_block( self.global, - caches, + self.caches, self.lib, self.level, self.scope, @@ -193,7 +186,7 @@ impl<'a, 's, 'ps, 'g, 'c, 't, 'pt> EvalContext<'a, 's, 'ps, 'g, 'c, 't, 'pt> { ), _ => self.engine.eval_expr( self.global, - caches, + self.caches, self.lib, self.level, self.scope, diff --git a/src/eval/expr.rs b/src/eval/expr.rs index 269ab992..89f0d4a7 100644 --- a/src/eval/expr.rs +++ b/src/eval/expr.rs @@ -4,8 +4,7 @@ use super::{Caches, EvalContext, GlobalRuntimeState, Target}; use crate::ast::{Expr, OpAssignment}; use crate::engine::{KEYWORD_THIS, OP_CONCAT}; use crate::types::dynamic::AccessMode; -use crate::types::RestoreOnDrop; -use crate::{Dynamic, Engine, Module, Position, RhaiResult, RhaiResultOf, Scope, Shared, ERR}; +use crate::{Dynamic, Engine, Position, RhaiResult, RhaiResultOf, Scope, SharedModule, ERR}; use std::num::NonZeroUsize; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -19,7 +18,7 @@ impl Engine { &self, global: &GlobalRuntimeState, namespace: &crate::ast::Namespace, - ) -> Option> { + ) -> Option { assert!(!namespace.is_empty()); let root = namespace.root(); @@ -52,7 +51,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &'s mut Scope, this_ptr: &'s mut Option<&mut Dynamic>, @@ -138,7 +137,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &'s mut Scope, this_ptr: &'s mut Option<&mut Dynamic>, @@ -174,7 +173,7 @@ impl Engine { // Check the variable resolver, if any if let Some(ref resolve_var) = self.resolve_var { - let context = EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr); + let context = EvalContext::new(self, global, 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)) => { @@ -222,7 +221,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -238,7 +237,9 @@ impl Engine { let reset = self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, expr)?; #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| g.debugger.reset_status(reset)); + let global = &mut *crate::types::RestoreOnDrop::lock(global, move |g| { + g.debugger.reset_status(reset) + }); self.track_operation(global, expr.position())?; @@ -269,7 +270,9 @@ impl Engine { let reset = self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, expr)?; #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| g.debugger.reset_status(reset)); + let global = &mut *crate::types::RestoreOnDrop::lock(global, move |g| { + g.debugger.reset_status(reset) + }); self.track_operation(global, expr.position())?; @@ -418,7 +421,7 @@ impl Engine { )) })?; let mut context = - EvalContext::new(self, global, Some(caches), lib, level, scope, this_ptr); + EvalContext::new(self, global, caches, lib, level, scope, this_ptr); let result = (custom_def.func)(&mut context, &expressions, &custom.state); diff --git a/src/eval/global_state.rs b/src/eval/global_state.rs index 935434ef..413dee13 100644 --- a/src/eval/global_state.rs +++ b/src/eval/global_state.rs @@ -28,7 +28,7 @@ pub struct GlobalRuntimeState { imports: crate::StaticVec, /// Stack of imported [modules][crate::Module]. #[cfg(not(feature = "no_module"))] - modules: crate::StaticVec>, + modules: crate::StaticVec, /// Source of the current context. /// /// No source if the string is empty. @@ -127,7 +127,7 @@ impl GlobalRuntimeState { #[cfg(not(feature = "no_module"))] #[inline(always)] #[must_use] - pub fn get_shared_import(&self, index: usize) -> Option> { + pub fn get_shared_import(&self, index: usize) -> Option { self.modules.get(index).cloned() } /// Get a mutable reference to the globally-imported [module][crate::Module] at a @@ -141,7 +141,7 @@ impl GlobalRuntimeState { pub(crate) fn get_shared_import_mut( &mut self, index: usize, - ) -> Option<&mut crate::Shared> { + ) -> Option<&mut crate::SharedModule> { self.modules.get_mut(index) } /// Get the index of a globally-imported [module][crate::Module] by name. @@ -165,7 +165,7 @@ impl GlobalRuntimeState { pub fn push_import( &mut self, name: impl Into, - module: impl Into>, + module: impl Into, ) { self.imports.push(name.into()); self.modules.push(module.into()); @@ -198,7 +198,7 @@ impl GlobalRuntimeState { #[inline] pub(crate) fn iter_imports_raw( &self, - ) -> impl Iterator)> { + ) -> impl Iterator { self.imports.iter().zip(self.modules.iter()).rev() } /// Get an iterator to the stack of globally-imported [modules][crate::Module] in forward order. @@ -208,7 +208,7 @@ impl GlobalRuntimeState { #[inline] pub fn scan_imports_raw( &self, - ) -> impl Iterator)> { + ) -> impl Iterator { self.imports.iter().zip(self.modules.iter()) } /// Can the particular function with [`Dynamic`] parameter(s) exist in the stack of @@ -316,11 +316,11 @@ impl GlobalRuntimeState { #[cfg(not(feature = "no_module"))] impl IntoIterator for GlobalRuntimeState { - type Item = (ImmutableString, crate::Shared); + type Item = (ImmutableString, crate::SharedModule); type IntoIter = std::iter::Rev< std::iter::Zip< smallvec::IntoIter<[ImmutableString; crate::STATIC_VEC_INLINE_SIZE]>, - smallvec::IntoIter<[crate::Shared; crate::STATIC_VEC_INLINE_SIZE]>, + smallvec::IntoIter<[crate::SharedModule; crate::STATIC_VEC_INLINE_SIZE]>, >, >; @@ -331,11 +331,11 @@ impl IntoIterator for GlobalRuntimeState { #[cfg(not(feature = "no_module"))] impl<'a> IntoIterator for &'a GlobalRuntimeState { - type Item = (&'a ImmutableString, &'a crate::Shared); + type Item = (&'a ImmutableString, &'a crate::SharedModule); type IntoIter = std::iter::Rev< std::iter::Zip< std::slice::Iter<'a, ImmutableString>, - std::slice::Iter<'a, crate::Shared>, + std::slice::Iter<'a, crate::SharedModule>, >, >; @@ -345,9 +345,7 @@ impl<'a> IntoIterator for &'a GlobalRuntimeState { } #[cfg(not(feature = "no_module"))] -impl, M: Into>> Extend<(K, M)> - for GlobalRuntimeState -{ +impl, M: Into> Extend<(K, M)> for GlobalRuntimeState { #[inline] fn extend>(&mut self, iter: T) { for (k, m) in iter { diff --git a/src/eval/stmt.rs b/src/eval/stmt.rs index 2841ecba..1e232ddc 100644 --- a/src/eval/stmt.rs +++ b/src/eval/stmt.rs @@ -8,10 +8,7 @@ use crate::ast::{ use crate::func::{get_builtin_op_assignment_fn, get_hasher}; use crate::types::dynamic::{AccessMode, Union}; use crate::types::RestoreOnDrop; -use crate::{ - Dynamic, Engine, ImmutableString, Module, Position, RhaiResult, RhaiResultOf, Scope, Shared, - ERR, INT, -}; +use crate::{Dynamic, Engine, Position, RhaiResult, RhaiResultOf, Scope, SharedModule, ERR, INT}; use std::hash::{Hash, Hasher}; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -29,7 +26,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -42,7 +39,7 @@ impl Engine { // Restore scope at end of block if necessary let orig_scope_len = scope.len(); - let scope = &mut *RestoreOnDrop::new_if(restore_orig_state, scope, move |s| { + let scope = &mut *RestoreOnDrop::lock_if(restore_orig_state, scope, move |s| { s.rewind(orig_scope_len); }); @@ -55,7 +52,7 @@ impl Engine { global.scope_level += 1; } - let global = &mut *RestoreOnDrop::new_if(restore_orig_state, global, move |g| { + let global = &mut *RestoreOnDrop::lock_if(restore_orig_state, global, move |g| { g.scope_level -= 1; #[cfg(not(feature = "no_module"))] g.truncate_imports(orig_imports_len); @@ -67,7 +64,7 @@ impl Engine { // Pop new function resolution caches at end of block let orig_fn_resolution_caches_len = caches.fn_resolution_caches_len(); - let caches = &mut *RestoreOnDrop::new(caches, move |c| { + let caches = &mut *RestoreOnDrop::lock(caches, move |c| { c.rewind_fn_resolution_caches(orig_fn_resolution_caches_len) }); @@ -96,10 +93,11 @@ impl Engine { .skip(imports_len) .any(|(.., m)| m.contains_indexed_global_functions()) { + // Different scenarios where the cache must be cleared - notice that this is + // expensive as all function resolutions must start again if caches.fn_resolution_caches_len() > orig_fn_resolution_caches_len { // When new module is imported with global functions and there is already - // a new cache, clear it - notice that this is expensive as all function - // resolutions must start again + // a new cache, just clear it caches.fn_resolution_cache_mut().clear(); } else if restore_orig_state { // When new module is imported with global functions, push a new cache @@ -120,20 +118,18 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, op_info: &OpAssignment, target: &mut Target, root: (&str, Position), - new_val: Dynamic, + mut new_val: Dynamic, ) -> RhaiResultOf<()> { + // Assignment to constant variable? if target.is_read_only() { - // Assignment to constant variable return Err(ERR::ErrorAssignmentToConstant(root.0.to_string(), root.1).into()); } - let mut new_val = new_val; - if op_info.is_op_assignment() { let OpAssignment { hash_op_assign, @@ -204,7 +200,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -215,7 +211,7 @@ impl Engine { let reset = self.run_debugger_with_reset(global, caches, lib, level, scope, this_ptr, stmt)?; #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| g.debugger.reset_status(reset)); + let global = &mut *RestoreOnDrop::lock(global, move |g| g.debugger.reset_status(reset)); // Coded this way for better branch prediction. // Popular branches are lifted out of the `match` statement into their own branches. @@ -240,11 +236,9 @@ impl Engine { .eval_expr(global, caches, lib, level, scope, this_ptr, rhs)? .flatten(); - let search_val = + let (mut lhs_ptr, pos) = self.search_namespace(global, caches, lib, level, scope, this_ptr, lhs)?; - let (mut lhs_ptr, pos) = search_val; - let var_name = x.3.as_str(); #[cfg(not(feature = "no_closure"))] @@ -267,16 +261,17 @@ impl Engine { return self .eval_op_assignment(global, caches, lib, level, op_info, lhs_ptr, root, rhs_val) .map(|_| Dynamic::UNIT); - } else { - let (op_info, BinaryExpr { lhs, rhs }) = &**x; + } + #[cfg(any(not(feature = "no_index"), not(feature = "no_object")))] + { let rhs_val = self.eval_expr(global, caches, lib, level, scope, this_ptr, rhs)?; // Check if the result is a string. If so, intern it. #[cfg(not(feature = "no_closure"))] - let is_string = !rhs_val.is_shared() && rhs_val.is::(); + let is_string = !rhs_val.is_shared() && rhs_val.is::(); #[cfg(feature = "no_closure")] - let is_string = rhs_val.is::(); + let is_string = rhs_val.is::(); let rhs_val = if is_string { self.get_interned_string( @@ -333,23 +328,20 @@ impl Engine { let (expr, if_block, else_block) = &**x; let guard_val = self - .eval_expr(global, caches, lib, level, scope, this_ptr, expr) - .and_then(|v| { - v.as_bool().map_err(|typ| { - self.make_type_mismatch_err::(typ, expr.position()) - }) - }); + .eval_expr(global, caches, lib, level, scope, this_ptr, expr)? + .as_bool() + .map_err(|typ| self.make_type_mismatch_err::(typ, expr.position()))?; - match guard_val { - Ok(true) if if_block.is_empty() => Ok(Dynamic::UNIT), - Ok(true) => self.eval_stmt_block( + if guard_val && !if_block.is_empty() { + self.eval_stmt_block( 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( + ) + } else if !guard_val && !else_block.is_empty() { + self.eval_stmt_block( global, caches, lib, level, scope, this_ptr, else_block, true, - ), - err => err.map(Into::into), + ) + } else { + Ok(Dynamic::UNIT) } } @@ -421,14 +413,11 @@ impl Engine { } } - if let Some(expr) = result { - self.eval_expr(global, caches, lib, level, scope, this_ptr, expr) - } else { - def_case.as_ref().map_or(Ok(Dynamic::UNIT), |&index| { - let def_expr = &expressions[index].expr; - self.eval_expr(global, caches, lib, level, scope, this_ptr, def_expr) + result + .or_else(|| def_case.as_ref().map(|&index| &expressions[index].expr)) + .map_or(Ok(Dynamic::UNIT), |expr| { + self.eval_expr(global, caches, lib, level, scope, this_ptr, expr) }) - } } // Loop @@ -439,17 +428,16 @@ impl Engine { loop { self.track_operation(global, body.position())?; } - } else { - loop { - match self.eval_stmt_block( - global, caches, lib, level, scope, this_ptr, body, true, - ) { - Ok(_) => (), - Err(err) => match *err { - ERR::LoopBreak(false, ..) => (), - ERR::LoopBreak(true, value, ..) => break Ok(value), - _ => break Err(err), - }, + } + + loop { + if let Err(err) = self + .eval_stmt_block(global, caches, lib, level, scope, this_ptr, body, true) + { + match *err { + ERR::LoopBreak(false, ..) => (), + ERR::LoopBreak(true, value, ..) => break Ok(value), + _ => break Err(err), } } } @@ -469,15 +457,17 @@ impl Engine { break Ok(Dynamic::UNIT); } - if !body.is_empty() { - if let Err(err) = self.eval_stmt_block( - global, caches, lib, level, scope, this_ptr, body, true, - ) { - match *err { - ERR::LoopBreak(false, ..) => (), - ERR::LoopBreak(true, value, ..) => break Ok(value), - _ => break Err(err), - } + if body.is_empty() { + continue; + } + + if let Err(err) = self + .eval_stmt_block(global, caches, lib, level, scope, this_ptr, body, true) + { + match *err { + ERR::LoopBreak(false, ..) => (), + ERR::LoopBreak(true, value, ..) => break Ok(value), + _ => break Err(err), } } } @@ -544,7 +534,7 @@ impl Engine { if let Some(func) = func { // Restore scope at end of statement let orig_scope_len = scope.len(); - let scope = &mut *RestoreOnDrop::new(scope, move |s| { + let scope = &mut *RestoreOnDrop::lock(scope, move |s| { s.rewind(orig_scope_len); }); @@ -616,12 +606,13 @@ impl Engine { Stmt::BreakLoop(expr, options, pos) => { let is_break = options.contains(ASTFlags::BREAK); - if let Some(ref expr) = expr { - self.eval_expr(global, caches, lib, level, scope, this_ptr, expr) - .and_then(|v| ERR::LoopBreak(is_break, v, *pos).into()) + let value = if let Some(ref expr) = expr { + self.eval_expr(global, caches, lib, level, scope, this_ptr, expr)? } else { - Err(ERR::LoopBreak(is_break, Dynamic::UNIT, *pos).into()) - } + Dynamic::UNIT + }; + + Err(ERR::LoopBreak(is_break, value, *pos).into()) } // Try/Catch statement @@ -638,9 +629,7 @@ impl Engine { match self .eval_stmt_block(global, caches, lib, level, scope, this_ptr, try_block, true) { - Ok(_) => self.eval_stmt_block( - global, caches, lib, level, scope, this_ptr, try_block, true, - ), + r @ Ok(_) => r, Err(err) if err.is_pseudo_error() => Err(err), Err(err) if !err.is_catchable() => Err(err), Err(mut err) => { @@ -682,7 +671,7 @@ impl Engine { // Restore scope at end of block let orig_scope_len = scope.len(); let scope = - &mut *RestoreOnDrop::new_if(!catch_var.is_empty(), scope, move |s| { + &mut *RestoreOnDrop::lock_if(!catch_var.is_empty(), scope, move |s| { s.rewind(orig_scope_len); }); @@ -757,7 +746,8 @@ impl Engine { nesting_level, will_shadow, }; - let context = EvalContext::new(self, global, None, lib, level, scope, this_ptr); + let context = + EvalContext::new(self, global, caches, lib, level, scope, this_ptr); if !filter(true, info, context)? { return Err(ERR::ErrorForbiddenVariable(var_name.to_string(), *pos).into()); @@ -917,7 +907,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, statements: &[Stmt], diff --git a/src/func/call.rs b/src/func/call.rs index 6c7ddf75..d7f0102d 100644 --- a/src/func/call.rs +++ b/src/func/call.rs @@ -11,8 +11,8 @@ use crate::eval::{Caches, FnResolutionCacheEntry, GlobalRuntimeState}; use crate::tokenizer::{is_valid_function_name, Token}; use crate::types::RestoreOnDrop; use crate::{ - calc_fn_hash, calc_fn_hash_full, Dynamic, Engine, FnArgsVec, FnPtr, ImmutableString, Module, - OptimizationLevel, Position, RhaiError, RhaiResult, RhaiResultOf, Scope, Shared, ERR, + calc_fn_hash, calc_fn_hash_full, Dynamic, Engine, FnArgsVec, FnPtr, ImmutableString, SharedModule, + OptimizationLevel, Position, RhaiError, RhaiResult, RhaiResultOf, Scope, ERR, }; #[cfg(feature = "no_std")] use hashbrown::hash_map::Entry; @@ -169,7 +169,7 @@ impl Engine { _global: &GlobalRuntimeState, caches: &'s mut Caches, local_entry: &'s mut Option, - lib: &[Shared], + lib: &[SharedModule], op_token: Option<&Token>, hash_base: u64, args: Option<&mut FnCallArgs>, @@ -325,7 +325,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, name: &str, op_token: Option<&Token>, @@ -371,7 +371,7 @@ impl Engine { } let args = - &mut *RestoreOnDrop::new_if(swap, &mut args, move |a| backup.restore_first_arg(a)); + &mut *RestoreOnDrop::lock_if(swap, &mut args, move |a| backup.restore_first_arg(a)); #[cfg(feature = "debugging")] if self.debugger.is_some() { @@ -537,7 +537,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, _scope: Option<&mut Scope>, fn_name: &str, @@ -585,7 +585,7 @@ impl Engine { } else { let hash_script = calc_fn_hash(None, fn_name.as_str(), num_params as usize); - self.has_script_fn(Some(global), caches, lib, hash_script) + self.has_script_fn(global, caches, lib, hash_script) } .into(), false, @@ -639,7 +639,7 @@ impl Engine { }; let orig_source = mem::replace(&mut global.source, source.clone()); - let global = &mut *RestoreOnDrop::new(global, move |g| g.source = orig_source); + let global = &mut *RestoreOnDrop::lock(global, move |g| g.source = orig_source); return if _is_method_call { // Method call of script function - map first argument to `this` @@ -668,7 +668,7 @@ impl Engine { backup.change_first_arg_to_copy(args); } - let args = &mut *RestoreOnDrop::new_if(swap, &mut args, move |a| { + let args = &mut *RestoreOnDrop::lock_if(swap, &mut args, move |a| { backup.restore_first_arg(a) }); @@ -694,7 +694,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -716,7 +716,7 @@ impl Engine { matches!(status, crate::eval::DebuggerStatus::FunctionExit(..)) }); #[cfg(feature = "debugging")] - let global = &mut *RestoreOnDrop::new(global, move |g| g.debugger.reset_status(reset)); + let global = &mut *RestoreOnDrop::lock(global, move |g| g.debugger.reset_status(reset)); self.eval_expr(global, caches, lib, level, scope, this_ptr, arg_expr) .map(|r| (r, arg_expr.start_position())) @@ -728,7 +728,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, fn_name: &str, mut hash: FnCallHashes, @@ -953,7 +953,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -1087,7 +1087,7 @@ impl Engine { false } else { let hash_script = calc_fn_hash(None, &fn_name, num_params as usize); - self.has_script_fn(Some(global), caches, lib, hash_script) + self.has_script_fn(global, caches, lib, hash_script) } .into()); } @@ -1244,7 +1244,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -1378,7 +1378,7 @@ impl Engine { let new_scope = &mut Scope::new(); let orig_source = mem::replace(&mut global.source, module.id_raw().cloned()); - let global = &mut *RestoreOnDrop::new(global, move |g| g.source = orig_source); + let global = &mut *RestoreOnDrop::lock(global, move |g| g.source = orig_source); self.call_script_fn( global, caches, lib, level, new_scope, &mut None, fn_def, &mut args, true, pos, @@ -1426,7 +1426,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, script: &str, @@ -1471,7 +1471,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, diff --git a/src/func/native.rs b/src/func/native.rs index 63823ecd..65f5119d 100644 --- a/src/func/native.rs +++ b/src/func/native.rs @@ -8,7 +8,7 @@ use crate::tokenizer::{is_valid_function_name, Token, TokenizeState}; use crate::types::dynamic::Variant; use crate::{ calc_fn_hash, Dynamic, Engine, EvalContext, FuncArgs, Module, Position, RhaiResult, - RhaiResultOf, StaticVec, VarDefInfo, ERR, + RhaiResultOf, SharedModule, StaticVec, VarDefInfo, ERR, }; use std::any::type_name; #[cfg(feature = "no_std")] @@ -74,7 +74,7 @@ pub struct NativeCallContext<'a> { /// The current [`GlobalRuntimeState`], if any. global: Option<&'a GlobalRuntimeState>, /// The current stack of loaded [modules][Module]. - lib: &'a [Shared], + lib: &'a [SharedModule], /// [Position] of the function call. pos: Position, /// The current nesting level of function calls. @@ -93,7 +93,7 @@ pub struct NativeCallContextStore { /// The current [`GlobalRuntimeState`], if any. pub global: GlobalRuntimeState, /// The current stack of loaded [modules][Module]. - pub lib: StaticVec>, + pub lib: StaticVec, /// [Position] of the function call. pub pos: Position, /// The current nesting level of function calls. @@ -116,7 +116,7 @@ impl<'a> &'a str, Option<&'a str>, &'a GlobalRuntimeState, - &'a [Shared], + &'a [SharedModule], Position, usize, )> for NativeCallContext<'a> @@ -128,7 +128,7 @@ impl<'a> &'a str, Option<&'a str>, &'a GlobalRuntimeState, - &'a [Shared], + &'a [SharedModule], Position, usize, ), @@ -145,9 +145,9 @@ impl<'a> } } -impl<'a> From<(&'a Engine, &'a str, &'a [Shared])> for NativeCallContext<'a> { +impl<'a> From<(&'a Engine, &'a str, &'a [SharedModule])> for NativeCallContext<'a> { #[inline(always)] - fn from(value: (&'a Engine, &'a str, &'a [Shared])) -> Self { + fn from(value: (&'a Engine, &'a str, &'a [SharedModule])) -> Self { Self { engine: value.0, fn_name: value.1, @@ -169,7 +169,7 @@ impl<'a> NativeCallContext<'a> { )] #[inline(always)] #[must_use] - pub fn new(engine: &'a Engine, fn_name: &'a str, lib: &'a [Shared]) -> Self { + pub fn new(engine: &'a Engine, fn_name: &'a str, lib: &'a [SharedModule]) -> Self { Self { engine, fn_name, @@ -193,7 +193,7 @@ impl<'a> NativeCallContext<'a> { fn_name: &'a str, source: Option<&'a str>, global: &'a GlobalRuntimeState, - lib: &'a [Shared], + lib: &'a [SharedModule], pos: Position, level: usize, ) -> Self { @@ -291,7 +291,7 @@ impl<'a> NativeCallContext<'a> { #[inline] pub(crate) fn iter_imports_raw( &self, - ) -> impl Iterator)> { + ) -> impl Iterator { self.global.iter().flat_map(|&g| g.iter_imports_raw()) } /// _(internals)_ The current [`GlobalRuntimeState`], if any. @@ -315,7 +315,7 @@ impl<'a> NativeCallContext<'a> { #[cfg(feature = "internals")] #[inline(always)] #[must_use] - pub const fn namespaces(&self) -> &[Shared] { + pub const fn namespaces(&self) -> &[SharedModule] { self.lib } /// Call a function inside the call context with the provided arguments. diff --git a/src/func/script.rs b/src/func/script.rs index 06fa916a..f8553165 100644 --- a/src/func/script.rs +++ b/src/func/script.rs @@ -4,7 +4,7 @@ use super::call::FnCallArgs; use crate::ast::ScriptFnDef; use crate::eval::{Caches, GlobalRuntimeState}; -use crate::{Dynamic, Engine, Module, Position, RhaiError, RhaiResult, Scope, Shared, ERR}; +use crate::{Dynamic, Engine, Position, RhaiError, RhaiResult, Scope, SharedModule, ERR}; use std::mem; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -26,7 +26,7 @@ impl Engine { &self, global: &mut GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], level: usize, scope: &mut Scope, this_ptr: &mut Option<&mut Dynamic>, @@ -228,9 +228,9 @@ impl Engine { #[must_use] pub(crate) fn has_script_fn( &self, - _global: Option<&GlobalRuntimeState>, + _global: &GlobalRuntimeState, caches: &mut Caches, - lib: &[Shared], + lib: &[SharedModule], hash_script: u64, ) -> bool { let cache = caches.fn_resolution_cache_mut(); @@ -247,7 +247,7 @@ impl Engine { #[cfg(not(feature = "no_module"))] let result = result || // Then check imported modules - _global.map_or(false, |m| m.contains_qualified_fn(hash_script)) + _global.contains_qualified_fn(hash_script) // Then check sub-modules || self.global_sub_modules.values().any(|m| m.contains_qualified_fn(hash_script)); diff --git a/src/lib.rs b/src/lib.rs index 12f36850..4fdb59f2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -240,6 +240,9 @@ pub use func::Locked; use func::{calc_fn_hash, calc_fn_hash_full, calc_var_hash}; +/// A shared [`Module`]. +type SharedModule = Shared; + pub use rhai_codegen::*; pub use func::{plugin, FuncArgs}; diff --git a/src/module/mod.rs b/src/module/mod.rs index 6cb59198..0d78e0e4 100644 --- a/src/module/mod.rs +++ b/src/module/mod.rs @@ -10,7 +10,7 @@ use crate::func::{ use crate::types::{dynamic::Variant, BloomFilterU64, CustomTypesCollection}; use crate::{ calc_fn_hash, calc_fn_hash_full, Dynamic, Identifier, ImmutableString, NativeCallContext, - RhaiResultOf, Shared, SmartString, StaticVec, + RhaiResultOf, Shared, SharedModule, SmartString, StaticVec, }; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -172,7 +172,7 @@ pub struct Module { /// Custom types. custom_types: Option, /// Sub-modules. - modules: Option>>, + modules: Option>, /// [`Module`] variables. variables: Option>, /// Flattened collection of all [`Module`] variables, including those in sub-modules. @@ -754,7 +754,7 @@ impl Module { #[cfg(not(feature = "no_module"))] #[inline] #[must_use] - pub(crate) fn get_sub_modules_mut(&mut self) -> &mut BTreeMap> { + pub(crate) fn get_sub_modules_mut(&mut self) -> &mut BTreeMap { // We must assume that the user has changed the sub-modules // (otherwise why take a mutable reference?) self.all_functions = None; @@ -822,7 +822,7 @@ impl Module { pub fn set_sub_module( &mut self, name: impl Into, - sub_module: impl Into>, + sub_module: impl Into, ) -> &mut Self { self.modules .get_or_insert_with(|| Default::default()) @@ -1830,7 +1830,7 @@ impl Module { /// Get an iterator to the sub-modules in the [`Module`]. #[inline] - pub fn iter_sub_modules(&self) -> impl Iterator)> { + pub fn iter_sub_modules(&self) -> impl Iterator { self.modules .iter() .flat_map(|m| m.iter().map(|(k, m)| (k.as_str(), m))) diff --git a/src/module/resolvers/collection.rs b/src/module/resolvers/collection.rs index 8a61d715..5310e6a8 100644 --- a/src/module/resolvers/collection.rs +++ b/src/module/resolvers/collection.rs @@ -1,5 +1,5 @@ use crate::{ - Engine, Module, ModuleResolver, Position, RhaiResultOf, Shared, StaticVec, ERR, + Engine, ModuleResolver, Position, RhaiResultOf, SharedModule, StaticVec, ERR, STATIC_VEC_INLINE_SIZE, }; #[cfg(feature = "no_std")] @@ -138,7 +138,7 @@ impl ModuleResolver for ModuleResolversCollection { source_path: Option<&str>, path: &str, pos: Position, - ) -> RhaiResultOf> { + ) -> RhaiResultOf { for resolver in &self.0 { match resolver.resolve(engine, source_path, path, pos) { Ok(module) => return Ok(module), diff --git a/src/module/resolvers/dummy.rs b/src/module/resolvers/dummy.rs index f5782ebc..4da90566 100644 --- a/src/module/resolvers/dummy.rs +++ b/src/module/resolvers/dummy.rs @@ -1,4 +1,4 @@ -use crate::{Engine, Module, ModuleResolver, Position, RhaiResultOf, Shared, ERR}; +use crate::{Engine, ModuleResolver, Position, RhaiResultOf, SharedModule, ERR}; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -45,7 +45,7 @@ impl ModuleResolver for DummyModuleResolver { _: Option<&str>, path: &str, pos: Position, - ) -> RhaiResultOf> { + ) -> RhaiResultOf { Err(ERR::ErrorModuleNotFound(path.into(), pos).into()) } } diff --git a/src/module/resolvers/file.rs b/src/module/resolvers/file.rs index d68ddfd1..ee56ac18 100644 --- a/src/module/resolvers/file.rs +++ b/src/module/resolvers/file.rs @@ -4,7 +4,8 @@ use crate::eval::GlobalRuntimeState; use crate::func::{locked_read, locked_write}; use crate::{ - Engine, Identifier, Locked, Module, ModuleResolver, Position, RhaiResultOf, Scope, Shared, ERR, + Engine, Identifier, Locked, Module, ModuleResolver, Position, RhaiResultOf, Scope, Shared, + SharedModule, ERR, }; use std::{ @@ -51,7 +52,7 @@ pub struct FileModuleResolver { extension: Identifier, cache_enabled: bool, scope: Scope<'static>, - cache: Locked>>, + cache: Locked>, } impl Default for FileModuleResolver { @@ -258,7 +259,7 @@ impl FileModuleResolver { /// The next time this path is resolved, the script file will be loaded once again. #[inline] #[must_use] - pub fn clear_cache_for_path(&mut self, path: impl AsRef) -> Option> { + pub fn clear_cache_for_path(&mut self, path: impl AsRef) -> Option { locked_write(&self.cache) .remove_entry(path.as_ref()) .map(|(.., v)| v) @@ -293,7 +294,7 @@ impl FileModuleResolver { source: Option<&str>, path: &str, pos: Position, - ) -> Result, Box> { + ) -> Result> { // Load relative paths from source if there is no base path specified let source_path = global .as_ref() @@ -344,7 +345,7 @@ impl ModuleResolver for FileModuleResolver { global: &mut GlobalRuntimeState, path: &str, pos: Position, - ) -> RhaiResultOf> { + ) -> RhaiResultOf { self.impl_resolve(engine, Some(global), None, path, pos) } @@ -355,7 +356,7 @@ impl ModuleResolver for FileModuleResolver { source: Option<&str>, path: &str, pos: Position, - ) -> RhaiResultOf> { + ) -> RhaiResultOf { self.impl_resolve(engine, None, source, path, pos) } diff --git a/src/module/resolvers/mod.rs b/src/module/resolvers/mod.rs index a7f2d5c4..6316a845 100644 --- a/src/module/resolvers/mod.rs +++ b/src/module/resolvers/mod.rs @@ -1,6 +1,6 @@ use crate::eval::GlobalRuntimeState; use crate::func::SendSync; -use crate::{Engine, Module, Position, RhaiResultOf, Shared, AST}; +use crate::{Engine, Position, RhaiResultOf, SharedModule, AST}; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -25,7 +25,7 @@ pub trait ModuleResolver: SendSync { source: Option<&str>, path: &str, pos: Position, - ) -> RhaiResultOf>; + ) -> RhaiResultOf; /// Resolve a module based on a path string, given a [`GlobalRuntimeState`]. /// @@ -38,7 +38,7 @@ pub trait ModuleResolver: SendSync { global: &mut GlobalRuntimeState, path: &str, pos: Position, - ) -> RhaiResultOf> { + ) -> RhaiResultOf { self.resolve(engine, global.source(), path, pos) } diff --git a/src/module/resolvers/stat.rs b/src/module/resolvers/stat.rs index 8338a43a..bd2b2638 100644 --- a/src/module/resolvers/stat.rs +++ b/src/module/resolvers/stat.rs @@ -1,5 +1,6 @@ use crate::{ - Engine, Identifier, Module, ModuleResolver, Position, RhaiResultOf, Shared, SmartString, ERR, + Engine, Identifier, Module, ModuleResolver, Position, RhaiResultOf, SharedModule, SmartString, + ERR, }; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -27,7 +28,7 @@ use std::{ /// engine.set_module_resolver(resolver); /// ``` #[derive(Debug, Clone, Default)] -pub struct StaticModuleResolver(BTreeMap>); +pub struct StaticModuleResolver(BTreeMap); impl StaticModuleResolver { /// Create a new [`StaticModuleResolver`]. @@ -65,7 +66,7 @@ impl StaticModuleResolver { } /// Remove a [module][Module] given its path. #[inline(always)] - pub fn remove(&mut self, path: &str) -> Option> { + pub fn remove(&mut self, path: &str) -> Option { self.0.remove(path) } /// Does the path exist? @@ -80,12 +81,12 @@ impl StaticModuleResolver { } /// Get an iterator of all the [modules][Module]. #[inline] - pub fn iter(&self) -> impl Iterator)> { + pub fn iter(&self) -> impl Iterator { self.0.iter().map(|(k, v)| (k.as_str(), v)) } /// Get a mutable iterator of all the [modules][Module]. #[inline] - pub fn iter_mut(&mut self) -> impl Iterator)> { + pub fn iter_mut(&mut self) -> impl Iterator { self.0.iter_mut().map(|(k, v)| (k.as_str(), v)) } /// Get an iterator of all the [module][Module] paths. @@ -95,7 +96,7 @@ impl StaticModuleResolver { } /// Get an iterator of all the [modules][Module]. #[inline(always)] - pub fn values(&self) -> impl Iterator> { + pub fn values(&self) -> impl Iterator { self.0.values() } /// Remove all [modules][Module]. @@ -130,8 +131,8 @@ impl StaticModuleResolver { } impl IntoIterator for StaticModuleResolver { - type Item = (Identifier, Shared); - type IntoIter = IntoIter>; + type Item = (Identifier, SharedModule); + type IntoIter = IntoIter; #[inline(always)] #[must_use] @@ -141,8 +142,8 @@ impl IntoIterator for StaticModuleResolver { } impl<'a> IntoIterator for &'a StaticModuleResolver { - type Item = (&'a Identifier, &'a Shared); - type IntoIter = Iter<'a, SmartString, Shared>; + type Item = (&'a Identifier, &'a SharedModule); + type IntoIter = Iter<'a, SmartString, SharedModule>; #[inline(always)] fn into_iter(self) -> Self::IntoIter { @@ -158,7 +159,7 @@ impl ModuleResolver for StaticModuleResolver { _: Option<&str>, path: &str, pos: Position, - ) -> RhaiResultOf> { + ) -> RhaiResultOf { self.0 .get(path) .cloned() diff --git a/src/optimizer.rs b/src/optimizer.rs index aa204777..b9804024 100644 --- a/src/optimizer.rs +++ b/src/optimizer.rs @@ -61,7 +61,7 @@ struct OptimizerState<'a> { caches: Caches, /// [Module][crate::Module] containing script-defined functions. #[cfg(not(feature = "no_function"))] - lib: &'a [crate::Shared], + lib: &'a [crate::SharedModule], /// Optimization level. optimization_level: OptimizationLevel, } @@ -71,7 +71,7 @@ impl<'a> OptimizerState<'a> { #[inline(always)] pub fn new( engine: &'a Engine, - #[cfg(not(feature = "no_function"))] lib: &'a [crate::Shared], + #[cfg(not(feature = "no_function"))] lib: &'a [crate::SharedModule], optimization_level: OptimizationLevel, ) -> Self { Self { @@ -1263,7 +1263,7 @@ fn optimize_top_level( statements: StmtBlockContainer, engine: &Engine, scope: &Scope, - #[cfg(not(feature = "no_function"))] lib: &[crate::Shared], + #[cfg(not(feature = "no_function"))] lib: &[crate::SharedModule], optimization_level: OptimizationLevel, ) -> StmtBlockContainer { let mut statements = statements; diff --git a/src/packages/mod.rs b/src/packages/mod.rs index 499a1762..dfa3d8d1 100644 --- a/src/packages/mod.rs +++ b/src/packages/mod.rs @@ -1,6 +1,6 @@ //! Module containing all built-in _packages_ available to Rhai, plus facilities to define custom packages. -use crate::{Engine, Module, Shared}; +use crate::{Engine, Module, SharedModule}; pub(crate) mod arithmetic; pub(crate) mod array_basic; @@ -99,7 +99,7 @@ pub trait Package { /// Get a reference to a shared module from this package. #[must_use] - fn as_shared_module(&self) -> Shared; + fn as_shared_module(&self) -> SharedModule; } /// Macro that makes it easy to define a _package_ (which is basically a shared [module][Module]) diff --git a/src/parser.rs b/src/parser.rs index ee107089..fd315bad 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -8,7 +8,7 @@ use crate::ast::{ SwitchCasesCollection, TryCatchBlock, }; use crate::engine::{Precedence, KEYWORD_THIS, OP_CONTAINS}; -use crate::eval::GlobalRuntimeState; +use crate::eval::{Caches, GlobalRuntimeState}; use crate::func::{hashing::get_hasher, StraightHashMap}; use crate::tokenizer::{ is_keyword_function, is_valid_function_name, is_valid_identifier, Token, TokenStream, @@ -2906,15 +2906,17 @@ impl Engine { nesting_level: level, will_shadow, }; - let mut this_ptr = None; + let caches = &mut Caches::new(); + let this_ptr = &mut None; + let context = EvalContext::new( self, &mut state.global, - None, + caches, &[], level, &mut state.stack, - &mut this_ptr, + this_ptr, ); match filter(false, info, context) { diff --git a/src/types/fn_ptr.rs b/src/types/fn_ptr.rs index b7ac5468..85355d4b 100644 --- a/src/types/fn_ptr.rs +++ b/src/types/fn_ptr.rs @@ -4,7 +4,7 @@ use crate::tokenizer::is_valid_function_name; use crate::types::dynamic::Variant; use crate::{ Dynamic, Engine, FuncArgs, ImmutableString, NativeCallContext, Position, RhaiError, RhaiResult, - RhaiResultOf, StaticVec, AST, ERR, + RhaiResultOf, SharedModule, StaticVec, AST, ERR, }; #[cfg(feature = "no_std")] use std::prelude::v1::*; @@ -150,9 +150,9 @@ impl FnPtr { let mut arg_values = crate::StaticVec::new_const(); args.parse(&mut arg_values); - let lib: &[crate::Shared] = &[ + let lib: &[SharedModule] = &[ #[cfg(not(feature = "no_function"))] - AsRef::>::as_ref(ast).clone(), + AsRef::::as_ref(ast).clone(), ]; let lib = if lib.first().map_or(true, |m| m.is_empty()) { &[][..] diff --git a/src/types/restore.rs b/src/types/restore.rs index d2e6cd87..6d0ad595 100644 --- a/src/types/restore.rs +++ b/src/types/restore.rs @@ -12,18 +12,26 @@ pub struct RestoreOnDrop<'a, T, R: FnOnce(&mut T)> { } impl<'a, T, R: FnOnce(&mut T)> RestoreOnDrop<'a, T, R> { - /// Create a new [`RestoreOnDrop`] that runs restoration logic at the end of scope only when - /// `need_restore` is `true`. + /// Create a new [`RestoreOnDrop`] that locks a mutable reference and runs restoration logic at + /// the end of scope only when `need_restore` is `true`. + /// + /// Beware that the end of scope means the end of its lifetime, not necessarily waiting until + /// the current block scope is exited. #[inline(always)] - pub fn new_if(need_restore: bool, value: &'a mut T, restore: R) -> Self { + pub fn lock_if(need_restore: bool, value: &'a mut T, restore: R) -> Self { Self { value, restore: if need_restore { Some(restore) } else { None }, } } - /// Create a new [`RestoreOnDrop`] that runs restoration logic at the end of scope. + + /// Create a new [`RestoreOnDrop`] that locks a mutable reference and runs restoration logic at + /// the end of scope. + /// + /// Beware that the end of scope means the end of its lifetime, not necessarily waiting until + /// the current block scope is exited. #[inline(always)] - pub fn new(value: &'a mut T, restore: R) -> Self { + pub fn lock(value: &'a mut T, restore: R) -> Self { Self { value, restore: Some(restore),