Refine strings interner.

src/api/compile.rs

@@ -2,7 +2,6 @@
 
 use crate::func::native::locked_write;
 use crate::parser::{ParseResult, ParseState};
-use crate::types::StringsInterner;
 use crate::{Engine, OptimizationLevel, Scope, AST};
 #[cfg(feature = "no_std")]
 use std::prelude::v1::*;
@@ -220,15 +219,11 @@ impl Engine {
     ) -> ParseResult<AST> {
         let (stream, tc) = self.lex(scripts.as_ref());
 
-        let mut interner;
-        let mut guard;
-        let interned_strings = if let Some(ref interner) = self.interned_strings {
-            guard = locked_write(interner).unwrap();
-            &mut *guard
-        } else {
-            interner = StringsInterner::new();
-            &mut interner
-        };
+        let guard = &mut self
+            .interned_strings
+            .as_ref()
+            .and_then(|interner| locked_write(interner));
+        let interned_strings = guard.as_deref_mut();
 
         let input = &mut stream.peekable();
         let lib = &mut <_>::default();
@@ -304,15 +299,11 @@ impl Engine {
         let scripts = [script];
         let (stream, t) = self.lex(&scripts);
 
-        let mut interner;
-        let mut guard;
-        let interned_strings = if let Some(ref interner) = self.interned_strings {
-            guard = locked_write(interner).unwrap();
-            &mut *guard
-        } else {
-            interner = StringsInterner::new();
-            &mut interner
-        };
+        let guard = &mut self
+            .interned_strings
+            .as_ref()
+            .and_then(|interner| locked_write(interner));
+        let interned_strings = guard.as_deref_mut();
 
         let input = &mut stream.peekable();
         let lib = &mut <_>::default();

src/api/eval.rs

@@ -4,7 +4,6 @@ use crate::eval::{Caches, GlobalRuntimeState};
 use crate::func::native::locked_write;
 use crate::parser::ParseState;
 use crate::types::dynamic::Variant;
-use crate::types::StringsInterner;
 use crate::{Dynamic, Engine, Position, RhaiResult, RhaiResultOf, Scope, AST, ERR};
 #[cfg(feature = "no_std")]
 use std::prelude::v1::*;
@@ -115,15 +114,11 @@ impl Engine {
     ) -> RhaiResultOf<T> {
         let scripts = [script];
         let ast = {
-            let mut interner;
-            let mut guard;
-            let interned_strings = if let Some(ref interner) = self.interned_strings {
-                guard = locked_write(interner).unwrap();
-                &mut *guard
-            } else {
-                interner = StringsInterner::new();
-                &mut interner
-            };
+            let guard = &mut self
+                .interned_strings
+                .as_ref()
+                .and_then(|interner| locked_write(interner));
+            let interned_strings = guard.as_deref_mut();
 
             let (stream, tc) = self.lex(&scripts);
 

src/api/formatting.rs

@@ -1,7 +1,7 @@
 //! Module that provide formatting services to the [`Engine`].
+use crate::func::locked_write;
 use crate::packages::iter_basic::{BitRange, CharsStream, StepRange};
 use crate::parser::{ParseResult, ParseState};
-use crate::types::StringsInterner;
 use crate::{
     Engine, ExclusiveRange, FnPtr, ImmutableString, InclusiveRange, Position, RhaiError,
     SmartString, ERR,
@@ -264,11 +264,16 @@ impl Engine {
 
         tc.borrow_mut().compressed = Some(String::new());
         stream.state.last_token = Some(SmartString::new_const());
-        let mut interner = StringsInterner::new();
+
+        let guard = &mut self
+            .interned_strings
+            .as_ref()
+            .and_then(|interner| locked_write(interner));
+        let interned_strings = guard.as_deref_mut();
 
         let input = &mut stream.peekable();
         let lib = &mut <_>::default();
-        let mut state = ParseState::new(None, &mut interner, input, tc, lib);
+        let mut state = ParseState::new(None, interned_strings, input, tc, lib);
 
         let mut _ast = self.parse(
             &mut state,

src/api/json.rs

@@ -5,7 +5,6 @@ use crate::func::native::locked_write;
 use crate::parser::{ParseSettingFlags, ParseState};
 use crate::tokenizer::Token;
 use crate::types::dynamic::Union;
-use crate::types::StringsInterner;
 use crate::{Dynamic, Engine, LexError, Map, RhaiResultOf};
 use std::fmt::Write;
 #[cfg(feature = "no_std")]
@@ -118,15 +117,11 @@ impl Engine {
         );
 
         let ast = {
-            let mut interner;
-            let mut guard;
-            let interned_strings = if let Some(ref interner) = self.interned_strings {
-                guard = locked_write(interner).unwrap();
-                &mut *guard
-            } else {
-                interner = StringsInterner::new();
-                &mut interner
-            };
+            let guard = &mut self
+                .interned_strings
+                .as_ref()
+                .and_then(|interner| locked_write(interner));
+            let interned_strings = guard.as_deref_mut();
 
             let input = &mut stream.peekable();
             let lib = &mut <_>::default();

src/api/limits.rs

@@ -1,6 +1,8 @@
 //! Settings for [`Engine`]'s limitations.
 #![cfg(not(feature = "unchecked"))]
 
+use crate::func::{locked_read, locked_write};
+use crate::types::StringsInterner;
 use crate::Engine;
 use std::num::{NonZeroU64, NonZeroUsize};
 #[cfg(feature = "no_std")]
@@ -20,6 +22,8 @@ pub mod default_limits {
     /// Not available under `no_function`.
     #[cfg(not(feature = "no_function"))]
     pub const MAX_FUNCTION_EXPR_DEPTH: usize = 16;
+    /// Maximum number of strings interned.
+    pub const MAX_STRINGS_INTERNED: usize = 256;
 }
 #[cfg(not(debug_assertions))]
 pub mod default_limits {
@@ -35,6 +39,8 @@ pub mod default_limits {
     /// Not available under `no_function`.
     #[cfg(not(feature = "no_function"))]
     pub const MAX_FUNCTION_EXPR_DEPTH: usize = 32;
+    /// Maximum number of strings interned.
+    pub const MAX_STRINGS_INTERNED: usize = 1024;
 }
 
 /// A type containing all the limits imposed by the [`Engine`].
@@ -344,4 +350,26 @@ impl Engine {
         #[cfg(feature = "no_object")]
         return 0;
     }
+    /// Set the maximum number of strings to be interned.
+    #[inline(always)]
+    pub fn set_max_strings_interned(&mut self, max: usize) -> &mut Self {
+        if max == 0 {
+            self.interned_strings = None;
+        } else if let Some(ref interner) = self.interned_strings {
+            if let Some(mut guard) = locked_write(interner) {
+                guard.set_max(max);
+            }
+        } else {
+            self.interned_strings = Some(StringsInterner::new(self.max_strings_interned()).into());
+        }
+        self
+    }
+    /// The maximum number of strings to be interned.
+    #[inline(always)]
+    #[must_use]
+    pub fn max_strings_interned(&self) -> usize {
+        self.interned_strings.as_ref().map_or(0, |interner| {
+            locked_read(interner).map_or(0, |guard| guard.max())
+        })
+    }
 }

src/api/run.rs

@@ -3,7 +3,6 @@
 use crate::eval::Caches;
 use crate::func::native::locked_write;
 use crate::parser::ParseState;
-use crate::types::StringsInterner;
 use crate::{Engine, RhaiResultOf, Scope, AST};
 #[cfg(feature = "no_std")]
 use std::prelude::v1::*;
@@ -61,15 +60,11 @@ impl Engine {
         let ast = {
             let (stream, tc) = self.lex(&scripts);
 
-            let mut interner;
-            let mut guard;
-            let interned_strings = if let Some(ref interner) = self.interned_strings {
-                guard = locked_write(interner).unwrap();
-                &mut *guard
-            } else {
-                interner = StringsInterner::new();
-                &mut interner
-            };
+            let guard = &mut self
+                .interned_strings
+                .as_ref()
+                .and_then(|interner| locked_write(interner));
+            let interned_strings = guard.as_deref_mut();
 
             let input = &mut stream.peekable();
             let lib = &mut <_>::default();

src/engine.rs

@@ -1,5 +1,6 @@
 //! Main module defining the script evaluation [`Engine`].
 
+use crate::api::limits::default_limits::MAX_STRINGS_INTERNED;
 use crate::api::options::LangOptions;
 use crate::func::native::{
     locked_write, OnDebugCallback, OnDefVarCallback, OnParseTokenCallback, OnPrintCallback,
@@ -96,7 +97,7 @@ pub struct Engine {
     pub(crate) module_resolver: Option<Box<dyn crate::ModuleResolver>>,
 
     /// Strings interner.
-    pub(crate) interned_strings: Option<Box<Locked<StringsInterner>>>,
+    pub(crate) interned_strings: Option<Locked<StringsInterner>>,
 
     /// A set of symbols to disable.
     pub(crate) disabled_symbols: BTreeSet<Identifier>,
@@ -279,7 +280,7 @@ impl Engine {
                 Some(Box::new(crate::module::resolvers::FileModuleResolver::new()));
         }
 
-        engine.interned_strings = Some(Locked::new(StringsInterner::new()).into());
+        engine.set_max_strings_interned(MAX_STRINGS_INTERNED);
 
         // default print/debug implementations
         #[cfg(not(feature = "no_std"))]

src/parser.rs

@@ -62,7 +62,7 @@ pub struct ParseState<'a, 't, 's, 'f> {
     /// Controls whether parsing of an expression should stop given the next token.
     pub expr_filter: fn(&Token) -> bool,
     /// Strings interner.
-    pub interned_strings: &'s mut StringsInterner,
+    pub interned_strings: Option<&'s mut StringsInterner>,
     /// External [scope][Scope] with constants.
     pub external_constants: Option<&'a Scope<'a>>,
     /// Global runtime state.
@@ -124,7 +124,7 @@ impl<'a, 't, 's, 'f> ParseState<'a, 't, 's, 'f> {
     #[must_use]
     pub fn new(
         external_constants: Option<&'a Scope>,
-        interned_strings: &'s mut StringsInterner,
+        interned_strings: Option<&'s mut StringsInterner>,
         input: &'t mut TokenStream<'a>,
         tokenizer_control: TokenizerControl,
         #[cfg(not(feature = "no_function"))] lib: &'f mut FnLib,
@@ -208,7 +208,7 @@ impl<'a, 't, 's, 'f> ParseState<'a, 't, 's, 'f> {
         #[cfg(not(feature = "no_closure"))]
         if self.allow_capture {
             if !is_func_name && index == 0 && !self.external_vars.iter().any(|v| v.name == name) {
-                let name = self.interned_strings.get(name);
+                let name = self.get_interned_string(name);
                 self.external_vars.push(Ident { name, pos: _pos });
             }
         } else {
@@ -247,7 +247,10 @@ impl<'a, 't, 's, 'f> ParseState<'a, 't, 's, 'f> {
         &mut self,
         text: impl AsRef<str> + Into<ImmutableString>,
     ) -> ImmutableString {
-        self.interned_strings.get(text)
+        match self.interned_strings {
+            Some(ref mut interner) => interner.get(text),
+            None => text.into(),
+        }
     }
 
     /// Get an interned property getter, creating one if it is not yet interned.
@@ -258,11 +261,14 @@ impl<'a, 't, 's, 'f> ParseState<'a, 't, 's, 'f> {
         &mut self,
         text: impl AsRef<str> + Into<ImmutableString>,
     ) -> ImmutableString {
-        self.interned_strings.get_with_mapper(
-            b'g',
-            |s| crate::engine::make_getter(s.as_ref()).into(),
-            text,
-        )
+        match self.interned_strings {
+            Some(ref mut interner) => interner.get_with_mapper(
+                b'g',
+                |s| crate::engine::make_getter(s.as_ref()).into(),
+                text,
+            ),
+            None => crate::engine::make_getter(text.as_ref()).into(),
+        }
     }
 
     /// Get an interned property setter, creating one if it is not yet interned.
@@ -273,11 +279,14 @@ impl<'a, 't, 's, 'f> ParseState<'a, 't, 's, 'f> {
         &mut self,
         text: impl AsRef<str> + Into<ImmutableString>,
     ) -> ImmutableString {
-        self.interned_strings.get_with_mapper(
-            b's',
-            |s| crate::engine::make_setter(s.as_ref()).into(),
-            text,
-        )
+        match self.interned_strings {
+            Some(ref mut interner) => interner.get_with_mapper(
+                b's',
+                |s| crate::engine::make_setter(s.as_ref()).into(),
+                text,
+            ),
+            None => crate::engine::make_setter(text.as_ref()).into(),
+        }
     }
 }
 
@@ -1465,7 +1474,7 @@ impl Engine {
             #[cfg(not(feature = "no_function"))]
             Token::Pipe | Token::Or if settings.has_option(LangOptions::ANON_FN) => {
                 // Build new parse state
-                let new_interner = &mut StringsInterner::new();
+                let new_interner = None;
                 let new_state = &mut ParseState::new(
                     state.external_constants,
                     new_interner,
@@ -1475,7 +1484,7 @@ impl Engine {
                 );
 
                 // We move the strings interner to the new parse state object by swapping it...
-                std::mem::swap(state.interned_strings, new_state.interned_strings);
+                std::mem::swap(&mut state.interned_strings, &mut new_state.interned_strings);
 
                 #[cfg(not(feature = "no_module"))]
                 {
@@ -1510,7 +1519,7 @@ impl Engine {
                 let result = self.parse_anon_fn(new_state, new_settings.level_up()?);
 
                 // Restore the strings interner by swapping it back
-                std::mem::swap(state.interned_strings, new_state.interned_strings);
+                std::mem::swap(&mut state.interned_strings, &mut new_state.interned_strings);
 
                 let (expr, fn_def, _externals) = result?;
 
@@ -3270,7 +3279,7 @@ impl Engine {
                         // Build new parse state
                         let new_state = &mut ParseState::new(
                             state.external_constants,
-                            state.interned_strings,
+                            state.interned_strings.as_deref_mut(),
                             state.input,
                             state.tokenizer_control.clone(),
                             state.lib,