Fix dropping issues with StaticVec and use it everywhere.

README.md

@@ -20,7 +20,7 @@ Rhai's current features set:
 * Easily [call a script-defined function](#calling-rhai-functions-from-rust) from Rust
 * Low compile-time overhead (~0.6 sec debug/~3 sec release for `rhai_runner` sample app)
 * Fairly efficient evaluation (1 million iterations in 0.75 sec on my 5 year old laptop)
-* Relatively little `unsafe` code (yes there are some for performance reasons, and all `unsafe` code is limited to
+* Relatively little `unsafe` code (yes there are some for performance reasons, and most `unsafe` code is limited to
   one single source file, all with names starting with `"unsafe_"`)
 * Sand-boxed (the scripting [`Engine`] can be declared immutable which cannot mutate the containing environment
   unless explicitly allowed via `RefCell` etc.)

src/engine.rs

@@ -8,7 +8,7 @@ use crate::module::Module;
 use crate::optimize::OptimizationLevel;
 use crate::packages::{CorePackage, Package, PackageLibrary, PackagesCollection, StandardPackage};
 use crate::parser::{Expr, FnAccess, FnDef, ReturnType, SharedFnDef, Stmt, AST};
-use crate::r#unsafe::unsafe_cast_var_name;
+use crate::r#unsafe::unsafe_cast_var_name_to_lifetime;
 use crate::result::EvalAltResult;
 use crate::scope::{EntryType as ScopeEntryType, Scope};
 use crate::token::Position;
@@ -756,7 +756,8 @@ impl Engine {
                             args.into_iter().map(|v| mem::take(*v)),
                         )
                         .map(|(name, value)| {
-                            let var_name = unsafe_cast_var_name(name.as_str(), &mut state);
+                            let var_name =
+                                unsafe_cast_var_name_to_lifetime(name.as_str(), &mut state);
                             (var_name, ScopeEntryType::Normal, value)
                         }),
                 );
@@ -1172,11 +1173,10 @@ impl Engine {
     ) -> Result<(), Box<EvalAltResult>> {
         match expr {
             Expr::FnCall(x) if x.1.is_none() => {
-                let mut arg_values = StaticVec::<Dynamic>::new();
+                let arg_values =
-
+                    x.3.iter()
-                for arg_expr in x.3.iter() {
+                        .map(|arg_expr| self.eval_expr(scope, state, arg_expr, level))
-                    arg_values.push(self.eval_expr(scope, state, arg_expr, level)?);
+                        .collect::<Result<StaticVec<Dynamic>, _>>()?;
-                }
 
                 idx_values.push(Dynamic::from(arg_values));
             }
@@ -1471,14 +1471,10 @@ impl Engine {
                     if !self.has_override(state, (hash_fn, *hash_fn_def)) {
                         // eval - only in function call style
                         let prev_len = scope.len();
+                        let pos = args_expr.get_ref(0).position();
 
                         // Evaluate the text string as a script
-                        let result = self.eval_script_expr(
+                        let result = self.eval_script_expr(scope, state, args.pop(), pos);
-                            scope,
-                            state,
-                            args.pop(),
-                            args_expr[0].position(),
-                        );
 
                         if scope.len() != prev_len {
                             // IMPORTANT! If the eval defines new variables in the current scope,
@@ -1709,7 +1705,7 @@ impl Engine {
                     .or_else(|| self.packages.get_iter(tid))
                 {
                     // Add the loop variable
-                    let var_name = unsafe_cast_var_name(name, &state);
+                    let var_name = unsafe_cast_var_name_to_lifetime(name, &state);
                     scope.push(var_name, ());
                     let index = scope.len() - 1;
                     state.scope_level += 1;
@@ -1775,7 +1771,7 @@ impl Engine {
             Stmt::Let(x) if x.1.is_some() => {
                 let ((var_name, pos), expr) = x.as_ref();
                 let val = self.eval_expr(scope, state, expr.as_ref().unwrap(), level)?;
-                let var_name = unsafe_cast_var_name(var_name, &state);
+                let var_name = unsafe_cast_var_name_to_lifetime(var_name, &state);
                 scope.push_dynamic_value(var_name, ScopeEntryType::Normal, val, false);
                 self.inc_operations(state, *pos)?;
                 Ok(Default::default())
@@ -1783,7 +1779,7 @@ impl Engine {
 
             Stmt::Let(x) => {
                 let ((var_name, pos), _) = x.as_ref();
-                let var_name = unsafe_cast_var_name(var_name, &state);
+                let var_name = unsafe_cast_var_name_to_lifetime(var_name, &state);
                 scope.push(var_name, ());
                 self.inc_operations(state, *pos)?;
                 Ok(Default::default())
@@ -1793,7 +1789,7 @@ impl Engine {
             Stmt::Const(x) if x.1.is_constant() => {
                 let ((var_name, pos), expr) = x.as_ref();
                 let val = self.eval_expr(scope, state, &expr, level)?;
-                let var_name = unsafe_cast_var_name(var_name, &state);
+                let var_name = unsafe_cast_var_name_to_lifetime(var_name, &state);
                 scope.push_dynamic_value(var_name, ScopeEntryType::Constant, val, true);
                 self.inc_operations(state, *pos)?;
                 Ok(Default::default())
@@ -1827,7 +1823,7 @@ impl Engine {
                             let module =
                                 resolver.resolve(self, Scope::new(), &path, expr.position())?;
 
-                            let mod_name = unsafe_cast_var_name(name, &state);
+                            let mod_name = unsafe_cast_var_name_to_lifetime(name, &state);
                             scope.push_module(mod_name, module);
 
                             state.modules += 1;
@@ -1848,7 +1844,7 @@ impl Engine {
 
             // Export statement
             Stmt::Export(list) => {
-                for ((id, id_pos), rename) in list.as_ref() {
+                for ((id, id_pos), rename) in list.iter() {
                     // Mark scope variables as public
                     if let Some(index) = scope
                         .get_index(id)

src/fn_call.rs

@@ -9,7 +9,7 @@ use crate::utils::StaticVec;
 /// Any data type that can be converted into a `Vec<Dynamic>` can be used
 /// as arguments to a function call.
 pub trait FuncArgs {
-    /// Convert to a `Vec<Dynamic>` of the function call arguments.
+    /// Convert to a `StaticVec<Dynamic>` of the function call arguments.
     fn into_vec(self) -> StaticVec<Dynamic>;
 }
 

src/lib.rs

@@ -91,7 +91,6 @@ mod utils;
 pub use any::Dynamic;
 pub use engine::Engine;
 pub use error::{ParseError, ParseErrorType};
-pub use fn_call::FuncArgs;
 pub use fn_native::NativeCallable;
 pub use fn_register::{RegisterDynamicFn, RegisterFn, RegisterResultFn};
 pub use module::Module;

src/module.rs

@@ -716,7 +716,7 @@ impl Module {
 ///
 /// A `StaticVec` is used because most module-level access contains only one level,
 /// and it is wasteful to always allocate a `Vec` with one element.
-#[derive(Clone, Eq, PartialEq, Hash, Default)]
+#[derive(Clone, Eq, PartialEq, Default)]
 pub struct ModuleRef(StaticVec<(String, Position)>, Option<NonZeroUsize>);
 
 impl fmt::Debug for ModuleRef {

src/optimize.rs

@@ -10,10 +10,12 @@ use crate::parser::{map_dynamic_to_expr, Expr, FnDef, ReturnType, Stmt, AST};
 use crate::result::EvalAltResult;
 use crate::scope::{Entry as ScopeEntry, EntryType as ScopeEntryType, Scope};
 use crate::token::Position;
+use crate::utils::StaticVec;
 
 use crate::stdlib::{
     boxed::Box,
     iter::empty,
+    mem,
     string::{String, ToString},
     vec,
     vec::Vec,
@@ -140,7 +142,11 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
 
             if preserve_result {
                 // -> { expr, Noop }
-                Stmt::Block(Box::new((vec![Stmt::Expr(Box::new(expr)), x.1], pos)))
+                let mut statements = StaticVec::new();
+                statements.push(Stmt::Expr(Box::new(expr)));
+                statements.push(x.1);
+
+                Stmt::Block(Box::new((statements, pos)))
             } else {
                 // -> expr
                 Stmt::Expr(Box::new(expr))
@@ -193,7 +199,8 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
                 Stmt::Break(pos) => {
                     // Only a single break statement - turn into running the guard expression once
                     state.set_dirty();
-                    let mut statements = vec![Stmt::Expr(Box::new(optimize_expr(expr, state)))];
+                    let mut statements = StaticVec::new();
+                    statements.push(Stmt::Expr(Box::new(optimize_expr(expr, state))));
                     if preserve_result {
                         statements.push(Stmt::Noop(pos))
                     }
@@ -229,24 +236,24 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
         // import expr as id;
         Stmt::Import(x) => Stmt::Import(Box::new((optimize_expr(x.0, state), x.1))),
         // { block }
-        Stmt::Block(x) => {
+        Stmt::Block(mut x) => {
             let orig_len = x.0.len(); // Original number of statements in the block, for change detection
             let orig_constants_len = state.constants.len(); // Original number of constants in the state, for restore later
             let pos = x.1;
 
             // Optimize each statement in the block
             let mut result: Vec<_> =
-                x.0.into_iter()
+                x.0.iter_mut()
                     .map(|stmt| match stmt {
                         // Add constant into the state
                         Stmt::Const(v) => {
-                            let ((name, pos), expr) = *v;
+                            let ((name, pos), expr) = v.as_mut();
-                            state.push_constant(&name, expr);
+                            state.push_constant(name, mem::take(expr));
                             state.set_dirty();
-                            Stmt::Noop(pos) // No need to keep constants
+                            Stmt::Noop(*pos) // No need to keep constants
                         }
                         // Optimize the statement
-                        _ => optimize_stmt(stmt, state, preserve_result),
+                        _ => optimize_stmt(mem::take(stmt), state, preserve_result),
                     })
                     .collect();
 
@@ -324,13 +331,13 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -
                     Stmt::Noop(pos)
                 }
                 // Only one let/import statement - leave it alone
-                [Stmt::Let(_)] | [Stmt::Import(_)] => Stmt::Block(Box::new((result, pos))),
+                [Stmt::Let(_)] | [Stmt::Import(_)] => Stmt::Block(Box::new((result.into(), pos))),
                 // Only one statement - promote
                 [_] => {
                     state.set_dirty();
                     result.remove(0)
                 }
-                _ => Stmt::Block(Box::new((result, pos))),
+                _ => Stmt::Block(Box::new((result.into(), pos))),
             }
         }
         // expr;
@@ -392,14 +399,14 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr {
         #[cfg(not(feature = "no_object"))]
         Expr::Dot(x) => match (x.0, x.1) {
             // map.string
-            (Expr::Map(m), Expr::Property(p)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
+            (Expr::Map(mut m), Expr::Property(p)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
                 let ((prop, _, _), _) = p.as_ref();
                 // Map literal where everything is pure - promote the indexed item.
                 // All other items can be thrown away.
                 state.set_dirty();
                 let pos = m.1;
-                m.0.into_iter().find(|((name, _), _)| name == prop)
+                m.0.iter_mut().find(|((name, _), _)| name == prop)
-                    .map(|(_, expr)| expr.set_position(pos))
+                    .map(|(_, expr)| mem::take(expr).set_position(pos))
                     .unwrap_or_else(|| Expr::Unit(pos))
             }
             // lhs.rhs
@@ -416,16 +423,16 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr {
                 // Array literal where everything is pure - promote the indexed item.
                 // All other items can be thrown away.
                 state.set_dirty();
-                a.0.remove(i.0 as usize).set_position(a.1)
+                a.0.get(i.0 as usize).set_position(a.1)
             }
             // map[string]
-            (Expr::Map(m), Expr::StringConstant(s)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
+            (Expr::Map(mut m), Expr::StringConstant(s)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
                 // Map literal where everything is pure - promote the indexed item.
                 // All other items can be thrown away.
                 state.set_dirty();
                 let pos = m.1;
-                m.0.into_iter().find(|((name, _), _)| name == &s.0)
+                m.0.iter_mut().find(|((name, _), _)| name == &s.0)
-                    .map(|(_, expr)| expr.set_position(pos))
+                    .map(|(_, expr)| mem::take(expr).set_position(pos))
                     .unwrap_or_else(|| Expr::Unit(pos))
             }
             // string[int]
@@ -439,15 +446,13 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr {
         },
         // [ items .. ]
         #[cfg(not(feature = "no_index"))]
-        Expr::Array(a) => Expr::Array(Box::new((a.0
+        Expr::Array(mut a) => Expr::Array(Box::new((a.0
-                            .into_iter()
+                                .iter_mut().map(|expr| optimize_expr(mem::take(expr), state))
-                            .map(|expr| optimize_expr(expr, state))
+                                .collect(), a.1))),
-                            .collect(), a.1))),
         // [ items .. ]
         #[cfg(not(feature = "no_object"))]
-        Expr::Map(m) => Expr::Map(Box::new((m.0
+        Expr::Map(mut m) => Expr::Map(Box::new((m.0
-                            .into_iter()
+                            .iter_mut().map(|((key, pos), expr)| ((mem::take(key), *pos), optimize_expr(mem::take(expr), state)))
-                            .map(|((key, pos), expr)| ((key, pos), optimize_expr(expr, state)))
                             .collect(), m.1))),
         // lhs in rhs
         Expr::In(x) => match (x.0, x.1) {
@@ -527,7 +532,7 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr {
 
         // Do not call some special keywords
         Expr::FnCall(mut x) if DONT_EVAL_KEYWORDS.contains(&(x.0).0.as_ref())=> {
-            x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
+            x.3 = x.3.iter_mut().map(|a| optimize_expr(mem::take(a), state)).collect();
             Expr::FnCall(x)
         }
 
@@ -542,7 +547,7 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr {
             // First search in script-defined functions (can override built-in)
             if state.fn_lib.iter().find(|(id, len)| *id == name && *len == args.len()).is_some() {
                 // A script-defined function overrides the built-in function - do not make the call
-                x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
+                x.3 = x.3.iter_mut().map(|a| optimize_expr(mem::take(a), state)).collect();
                 return Expr::FnCall(x);
             }
 
@@ -574,14 +579,14 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr {
                     })
                 ).unwrap_or_else(|| {
                     // Optimize function call arguments
-                    x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
+                    x.3 = x.3.iter_mut().map(|a| optimize_expr(mem::take(a), state)).collect();
                     Expr::FnCall(x)
                 })
         }
 
         // id(args ..) -> optimize function call arguments
         Expr::FnCall(mut x) => {
-            x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
+            x.3 = x.3.iter_mut().map(|a| optimize_expr(mem::take(a), state)).collect();
             Expr::FnCall(x)
         }
 

src/packages/mod.rs

@@ -2,6 +2,7 @@
 
 use crate::fn_native::{NativeCallable, SharedIteratorFunction};
 use crate::module::Module;
+use crate::utils::StaticVec;
 
 use crate::stdlib::{any::TypeId, boxed::Box, collections::HashMap, rc::Rc, sync::Arc, vec::Vec};
 
@@ -54,7 +55,7 @@ pub type PackageLibrary = Arc<Module>;
 #[derive(Clone, Default)]
 pub(crate) struct PackagesCollection {
     /// Collection of `PackageLibrary` instances.
-    packages: Vec<PackageLibrary>,
+    packages: StaticVec<PackageLibrary>,
 }
 
 impl PackagesCollection {

src/packages/string_more.rs

@@ -1,6 +1,7 @@
 use crate::def_package;
 use crate::module::FuncReturn;
 use crate::parser::INT;
+use crate::utils::StaticVec;
 
 #[cfg(not(feature = "no_index"))]
 use crate::engine::Array;
@@ -29,7 +30,7 @@ fn sub_string(s: &mut String, start: INT, len: INT) -> FuncReturn<String> {
         start as usize
     };
 
-    let chars: Vec<_> = s.chars().collect();
+    let chars: StaticVec<_> = s.chars().collect();
 
     let len = if offset + (len as usize) > chars.len() {
         chars.len() - offset
@@ -37,7 +38,7 @@ fn sub_string(s: &mut String, start: INT, len: INT) -> FuncReturn<String> {
         len as usize
     };
 
-    Ok(chars[offset..][..len].into_iter().collect())
+    Ok(chars.iter().skip(offset).take(len).cloned().collect())
 }
 fn crop_string(s: &mut String, start: INT, len: INT) -> FuncReturn<()> {
     let offset = if s.is_empty() || len <= 0 {
@@ -52,7 +53,7 @@ fn crop_string(s: &mut String, start: INT, len: INT) -> FuncReturn<()> {
         start as usize
     };
 
-    let chars: Vec<_> = s.chars().collect();
+    let chars: StaticVec<_> = s.chars().collect();
 
     let len = if offset + (len as usize) > chars.len() {
         chars.len() - offset
@@ -62,8 +63,10 @@ fn crop_string(s: &mut String, start: INT, len: INT) -> FuncReturn<()> {
 
     s.clear();
 
-    chars[offset..][..len]
+    chars
-        .into_iter()
+        .iter()
+        .skip(offset)
+        .take(len)
         .for_each(|&ch| s.push(ch));
 
     Ok(())
@@ -189,9 +192,9 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str
         "truncate",
         |s: &mut String, len: INT| {
             if len >= 0 {
-                let chars: Vec<_> = s.chars().take(len as usize).collect();
+                let chars: StaticVec<_> = s.chars().take(len as usize).collect();
                 s.clear();
-                chars.into_iter().for_each(|ch| s.push(ch));
+                chars.iter().for_each(|&ch| s.push(ch));
             } else {
                 s.clear();
             }

src/parser.rs

@@ -7,7 +7,7 @@ use crate::error::{LexError, ParseError, ParseErrorType};
 use crate::optimize::{optimize_into_ast, OptimizationLevel};
 use crate::scope::{EntryType as ScopeEntryType, Scope};
 use crate::token::{Position, Token, TokenIterator};
-use crate::utils::EMPTY_TYPE_ID;
+use crate::utils::{StaticVec, EMPTY_TYPE_ID};
 
 #[cfg(not(feature = "no_module"))]
 use crate::module::ModuleRef;
@@ -195,7 +195,7 @@ pub struct FnDef {
     /// Function access mode.
     pub access: FnAccess,
     /// Names of function parameters.
-    pub params: Vec<String>,
+    pub params: StaticVec<String>,
     /// Function body.
     pub body: Stmt,
     /// Position of the function definition.
@@ -294,7 +294,7 @@ pub enum Stmt {
     /// const id = expr
     Const(Box<((String, Position), Expr)>),
     /// { stmt; ... }
-    Block(Box<(Vec<Stmt>, Position)>),
+    Block(Box<(StaticVec<Stmt>, Position)>),
     /// { stmt }
     Expr(Box<Expr>),
     /// continue
@@ -306,7 +306,13 @@ pub enum Stmt {
     /// import expr as module
     Import(Box<(Expr, (String, Position))>),
     /// expr id as name, ...
-    Export(Box<Vec<((String, Position), Option<(String, Position)>)>>),
+    Export(Box<StaticVec<((String, Position), Option<(String, Position)>)>>),
+}
+
+impl Default for Stmt {
+    fn default() -> Self {
+        Self::Noop(Default::default())
+    }
 }
 
 impl Stmt {
@@ -324,7 +330,7 @@ impl Stmt {
             Stmt::Loop(x) => x.position(),
             Stmt::For(x) => x.2.position(),
             Stmt::Import(x) => (x.1).1,
-            Stmt::Export(x) => (x.get(0).unwrap().0).1,
+            Stmt::Export(x) => (x.get_ref(0).0).1,
         }
     }
 
@@ -406,7 +412,7 @@ pub enum Expr {
             (Cow<'static, str>, Position),
             MRef,
             u64,
-            Vec<Expr>,
+            StaticVec<Expr>,
             Option<Dynamic>,
         )>,
     ),
@@ -417,9 +423,9 @@ pub enum Expr {
     /// expr[expr]
     Index(Box<(Expr, Expr, Position)>),
     /// [ expr, ... ]
-    Array(Box<(Vec<Expr>, Position)>),
+    Array(Box<(StaticVec<Expr>, Position)>),
     /// #{ name:expr, ... }
-    Map(Box<(Vec<((String, Position), Expr)>, Position)>),
+    Map(Box<(StaticVec<((String, Position), Expr)>, Position)>),
     /// lhs in rhs
     In(Box<(Expr, Expr, Position)>),
     /// lhs && rhs
@@ -434,6 +440,12 @@ pub enum Expr {
     Unit(Position),
 }
 
+impl Default for Expr {
+    fn default() -> Self {
+        Self::Unit(Default::default())
+    }
+}
+
 impl Expr {
     /// Get the `Dynamic` value of a constant expression.
     ///
@@ -713,7 +725,7 @@ fn parse_call_expr<'a>(
     begin: Position,
     allow_stmt_expr: bool,
 ) -> Result<Expr, Box<ParseError>> {
-    let mut args = Vec::new();
+    let mut args = StaticVec::new();
 
     match input.peek().unwrap() {
         // id <EOF>
@@ -1013,7 +1025,7 @@ fn parse_array_literal<'a>(
     pos: Position,
     allow_stmt_expr: bool,
 ) -> Result<Expr, Box<ParseError>> {
-    let mut arr = Vec::new();
+    let mut arr = StaticVec::new();
 
     if !match_token(input, Token::RightBracket)? {
         while !input.peek().unwrap().0.is_eof() {
@@ -1056,7 +1068,7 @@ fn parse_map_literal<'a>(
     pos: Position,
     allow_stmt_expr: bool,
 ) -> Result<Expr, Box<ParseError>> {
-    let mut map = Vec::new();
+    let mut map = StaticVec::new();
 
     if !match_token(input, Token::RightBrace)? {
         while !input.peek().unwrap().0.is_eof() {
@@ -1296,15 +1308,17 @@ fn parse_unary<'a>(
                 Expr::FloatConstant(x) => Ok(Expr::FloatConstant(Box::new((-x.0, x.1)))),
 
                 // Call negative function
-                e => {
+                expr => {
                     let op = "-";
                     let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2));
+                    let mut args = StaticVec::new();
+                    args.push(expr);
 
                     Ok(Expr::FnCall(Box::new((
                         (op.into(), pos),
                         None,
                         hash,
-                        vec![e],
+                        args,
                         None,
                     ))))
                 }
@@ -1318,7 +1332,8 @@ fn parse_unary<'a>(
         // !expr
         (Token::Bang, _) => {
             let pos = eat_token(input, Token::Bang);
-            let expr = vec![parse_primary(input, stack, allow_stmt_expr)?];
+            let mut args = StaticVec::new();
+            args.push(parse_primary(input, stack, allow_stmt_expr)?);
 
             let op = "!";
             let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2));
@@ -1327,7 +1342,7 @@ fn parse_unary<'a>(
                 (op.into(), pos),
                 None,
                 hash,
-                expr,
+                args,
                 Some(false.into()), // NOT operator, when operating on invalid operand, defaults to false
             ))))
         }
@@ -1412,9 +1427,13 @@ fn parse_op_assignment_stmt<'a>(
     let rhs = parse_expr(input, stack, allow_stmt_expr)?;
 
     // lhs op= rhs -> lhs = op(lhs, rhs)
-    let args = vec![lhs_copy, rhs];
+    let mut args = StaticVec::new();
+    args.push(lhs_copy);
+    args.push(rhs);
+
     let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(args.len()));
     let rhs_expr = Expr::FnCall(Box::new(((op.into(), pos), None, hash, args, None)));
+
     make_assignment_stmt(stack, lhs, rhs_expr, pos)
 }
 
@@ -1695,7 +1714,10 @@ fn parse_binary_op<'a>(
         let cmp_def = Some(false.into());
         let op = op_token.syntax();
         let hash = calc_fn_hash(empty(), &op, repeat(EMPTY_TYPE_ID()).take(2));
-        let mut args = vec![current_lhs, rhs];
+
+        let mut args = StaticVec::new();
+        args.push(current_lhs);
+        args.push(rhs);
 
         current_lhs = match op_token {
             Token::Plus => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))),
@@ -1721,13 +1743,13 @@ fn parse_binary_op<'a>(
             }
 
             Token::Or => {
-                let rhs = args.pop().unwrap();
+                let rhs = args.pop();
-                let current_lhs = args.pop().unwrap();
+                let current_lhs = args.pop();
                 Expr::Or(Box::new((current_lhs, rhs, pos)))
             }
             Token::And => {
-                let rhs = args.pop().unwrap();
+                let rhs = args.pop();
-                let current_lhs = args.pop().unwrap();
+                let current_lhs = args.pop();
                 Expr::And(Box::new((current_lhs, rhs, pos)))
             }
             Token::Ampersand => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))),
@@ -1735,15 +1757,15 @@ fn parse_binary_op<'a>(
             Token::XOr => Expr::FnCall(Box::new(((op, pos), None, hash, args, None))),
 
             Token::In => {
-                let rhs = args.pop().unwrap();
+                let rhs = args.pop();
-                let current_lhs = args.pop().unwrap();
+                let current_lhs = args.pop();
                 make_in_expr(current_lhs, rhs, pos)?
             }
 
             #[cfg(not(feature = "no_object"))]
             Token::Period => {
-                let mut rhs = args.pop().unwrap();
+                let mut rhs = args.pop();
-                let current_lhs = args.pop().unwrap();
+                let current_lhs = args.pop();
 
                 match &mut rhs {
                     // current_lhs.rhs(...) - method call
@@ -2025,7 +2047,7 @@ fn parse_import<'a>(
 fn parse_export<'a>(input: &mut Peekable<TokenIterator<'a>>) -> Result<Stmt, Box<ParseError>> {
     eat_token(input, Token::Export);
 
-    let mut exports = Vec::new();
+    let mut exports = StaticVec::new();
 
     loop {
         let (id, id_pos) = match input.next().unwrap() {
@@ -2098,7 +2120,7 @@ fn parse_block<'a>(
         }
     };
 
-    let mut statements = Vec::new();
+    let mut statements = StaticVec::new();
     let prev_len = stack.len();
 
     while !match_token(input, Token::RightBrace)? {

src/unsafe.rs

@@ -47,9 +47,9 @@ pub fn unsafe_cast_box<X: Variant, T: Variant>(item: Box<X>) -> Result<Box<T>, B
 /// current `Scope` without cloning the variable name.  Doing this is safe because all local
 /// variables in the `Scope` are cleared out before existing the block.
 ///
-/// Force-casting a local variable lifetime to the current `Scope`'s larger lifetime saves
+/// Force-casting a local variable's lifetime to the current `Scope`'s larger lifetime saves
 /// on allocations and string cloning, thus avoids us having to maintain a chain of `Scope`'s.
-pub fn unsafe_cast_var_name<'s>(name: &str, state: &State) -> Cow<'s, str> {
+pub fn unsafe_cast_var_name_to_lifetime<'s>(name: &str, state: &State) -> Cow<'s, str> {
     // If not at global level, we can force-cast
     if state.scope_level > 0 {
         // WARNING - force-cast the variable name into the scope's lifetime to avoid cloning it
@@ -62,7 +62,7 @@ pub fn unsafe_cast_var_name<'s>(name: &str, state: &State) -> Cow<'s, str> {
     }
 }
 
-/// Provide a type instance that is memory-zeroed.
+/// Provide a type instance that is uninitialized.
-pub fn unsafe_zeroed<T>() -> T {
+pub fn unsafe_uninit<T>() -> T {
-    unsafe { mem::MaybeUninit::zeroed().assume_init() }
+    unsafe { mem::MaybeUninit::uninit().assume_init() }
 }

src/utils.rs

@@ -1,6 +1,10 @@
 //! Module containing various utility types and functions.
+//!
+//! # Safety
+//!
+//! The `StaticVec` type has some `unsafe` blocks.
 
-use crate::r#unsafe::unsafe_zeroed;
+use crate::r#unsafe::unsafe_uninit;
 
 use crate::stdlib::{
     any::TypeId,
@@ -8,6 +12,7 @@ use crate::stdlib::{
     hash::{Hash, Hasher},
     iter::FromIterator,
     mem,
+    ops::Drop,
     vec::Vec,
 };
 
@@ -47,6 +52,8 @@ pub fn calc_fn_spec<'a>(
     s.finish()
 }
 
+const MAX_STATIC_VEC: usize = 4;
+
 /// A type to hold a number of values in static storage for speed, and any spill-overs in a `Vec`.
 ///
 /// This is essentially a knock-off of the [`staticvec`](https://crates.io/crates/staticvec) crate.
@@ -54,22 +61,57 @@ pub fn calc_fn_spec<'a>(
 ///
 /// # Safety
 ///
-/// This type uses some unsafe code (mainly to zero out unused array slots) for efficiency.
+/// This type uses some unsafe code (mainly for uninitialized/unused array slots) for efficiency.
 //
 // TODO - remove unsafe code
-#[derive(Clone, Hash)]
 pub struct StaticVec<T> {
     /// Total number of values held.
     len: usize,
-    /// Static storage. 4 slots should be enough for most cases - i.e. four levels of indirection.
+    /// Static storage. 4 slots should be enough for most cases - i.e. four items of fast, no-allocation access.
-    list: [T; 4],
+    list: [mem::MaybeUninit<T>; MAX_STATIC_VEC],
     /// Dynamic storage. For spill-overs.
     more: Vec<T>,
 }
 
+impl<T> Drop for StaticVec<T> {
+    fn drop(&mut self) {
+        self.clear();
+    }
+}
+
+impl<T> Default for StaticVec<T> {
+    fn default() -> Self {
+        Self {
+            len: 0,
+            list: unsafe_uninit(),
+            more: Vec::new(),
+        }
+    }
+}
+
 impl<T: PartialEq> PartialEq for StaticVec<T> {
     fn eq(&self, other: &Self) -> bool {
-        self.len == other.len && self.list == other.list && self.more == other.more
+        self.len == other.len
+            //&& self.list[0..self.len] == other.list[0..self.len]
+            && self.more == other.more
+    }
+}
+
+impl<T: Clone> Clone for StaticVec<T> {
+    fn clone(&self) -> Self {
+        let mut value: Self = Default::default();
+        value.len = self.len;
+
+        if self.len <= self.list.len() {
+            for x in 0..self.len {
+                let item: &T = unsafe { mem::transmute(self.list.get(x).unwrap()) };
+                value.list[x] = mem::MaybeUninit::new(item.clone());
+            }
+        } else {
+            value.more = self.more.clone();
+        }
+
+        value
     }
 }
 
@@ -87,35 +129,75 @@ impl<T> FromIterator<T> for StaticVec<T> {
     }
 }
 
-impl<T> Default for StaticVec<T> {
-    fn default() -> Self {
-        Self {
-            len: 0,
-            list: unsafe_zeroed(),
-            more: Vec::new(),
-        }
-    }
-}
-
 impl<T> StaticVec<T> {
+    fn extract(value: mem::MaybeUninit<T>) -> T {
+        unsafe { value.assume_init() }
+    }
     /// Create a new `StaticVec`.
     pub fn new() -> Self {
         Default::default()
     }
+    /// Empty the `StaticVec`.
+    pub fn clear(&mut self) {
+        if self.len <= self.list.len() {
+            for x in 0..self.len {
+                Self::extract(mem::replace(
+                    self.list.get_mut(x).unwrap(),
+                    mem::MaybeUninit::uninit(),
+                ));
+            }
+        } else {
+            self.more.clear();
+        }
+        self.len = 0;
+    }
     /// Push a new value to the end of this `StaticVec`.
     pub fn push<X: Into<T>>(&mut self, value: X) {
         if self.len == self.list.len() {
             // Move the fixed list to the Vec
-            for x in 0..self.list.len() {
+            self.more.extend(
-                let def_val: T = unsafe_zeroed();
+                self.list
-                self.more
+                    .iter_mut()
-                    .push(mem::replace(self.list.get_mut(x).unwrap(), def_val));
+                    .map(|v| mem::replace(v, mem::MaybeUninit::uninit()))
-            }
+                    .map(Self::extract),
-            self.more.push(value.into());
+            );
-        } else if self.len > self.list.len() {
             self.more.push(value.into());
+        } else if self.len < self.list.len() {
+            mem::replace(
+                self.list.get_mut(self.len).unwrap(),
+                mem::MaybeUninit::new(value.into()),
+            );
         } else {
-            self.list[self.len] = value.into();
+            self.more.push(value.into());
+        }
+        self.len += 1;
+    }
+    /// Insert a new value to this `StaticVec` at a particular position.
+    pub fn insert<X: Into<T>>(&mut self, index: usize, value: X) {
+        if index > self.len {
+            panic!("index OOB in StaticVec");
+        }
+
+        if self.len == self.list.len() {
+            // Move the fixed list to the Vec
+            self.more.extend(
+                self.list
+                    .iter_mut()
+                    .map(|v| mem::replace(v, mem::MaybeUninit::uninit()))
+                    .map(Self::extract),
+            );
+            self.more.insert(index, value.into());
+        } else if self.len < self.list.len() {
+            for x in (index..self.len).rev() {
+                let temp = mem::replace(self.list.get_mut(x).unwrap(), mem::MaybeUninit::uninit());
+                mem::replace(self.list.get_mut(x + 1).unwrap(), temp);
+            }
+            mem::replace(
+                self.list.get_mut(index).unwrap(),
+                mem::MaybeUninit::new(value.into()),
+            );
+        } else {
+            self.more.insert(index, value.into());
         }
         self.len += 1;
     }
@@ -125,18 +207,25 @@ impl<T> StaticVec<T> {
     ///
     /// Panics if the `StaticVec` is empty.
     pub fn pop(&mut self) -> T {
-        let result = if self.len <= 0 {
+        if self.len <= 0 {
-            panic!("nothing to pop!")
+            panic!("nothing to pop!");
-        } else if self.len <= self.list.len() {
+        }
-            let def_val: T = unsafe_zeroed();
+
-            mem::replace(self.list.get_mut(self.len - 1).unwrap(), def_val)
+        let result = if self.len <= self.list.len() {
+            Self::extract(mem::replace(
+                self.list.get_mut(self.len - 1).unwrap(),
+                mem::MaybeUninit::uninit(),
+            ))
         } else {
             let r = self.more.pop().unwrap();
 
             // Move back to the fixed list
             if self.more.len() == self.list.len() {
-                for x in 0..self.list.len() {
+                for index in (0..self.list.len()).rev() {
-                    self.list[self.list.len() - 1 - x] = self.more.pop().unwrap();
+                    mem::replace(
+                        self.list.get_mut(index).unwrap(),
+                        mem::MaybeUninit::new(self.more.pop().unwrap()),
+                    );
                 }
             }
 
@@ -151,6 +240,10 @@ impl<T> StaticVec<T> {
     pub fn len(&self) -> usize {
         self.len
     }
+    /// Is this `StaticVec` empty?
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
     /// Get a reference to the item at a particular index.
     ///
     /// # Panics
@@ -161,8 +254,10 @@ impl<T> StaticVec<T> {
             panic!("index OOB in StaticVec");
         }
 
-        if self.len < self.list.len() {
+        let list: &[T; MAX_STATIC_VEC] = unsafe { mem::transmute(&self.list) };
-            self.list.get(index).unwrap()
+
+        if self.len <= list.len() {
+            list.get(index).unwrap()
         } else {
             self.more.get(index).unwrap()
         }
@@ -177,46 +272,52 @@ impl<T> StaticVec<T> {
             panic!("index OOB in StaticVec");
         }
 
-        if self.len < self.list.len() {
+        let list: &mut [T; MAX_STATIC_VEC] = unsafe { mem::transmute(&mut self.list) };
-            self.list.get_mut(index).unwrap()
+
+        if self.len <= list.len() {
+            list.get_mut(index).unwrap()
         } else {
             self.more.get_mut(index).unwrap()
         }
     }
     /// Get an iterator to entries in the `StaticVec`.
     pub fn iter(&self) -> impl Iterator<Item = &T> {
-        if self.len > self.list.len() {
+        let list: &[T; MAX_STATIC_VEC] = unsafe { mem::transmute(&self.list) };
-            self.more.iter()
+
+        if self.len <= list.len() {
+            list[..self.len].iter()
         } else {
-            self.list[..self.len].iter()
+            self.more.iter()
         }
     }
     /// Get a mutable iterator to entries in the `StaticVec`.
     pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
-        if self.len > self.list.len() {
+        let list: &mut [T; MAX_STATIC_VEC] = unsafe { mem::transmute(&mut self.list) };
-            self.more.iter_mut()
+
+        if self.len <= list.len() {
+            list[..self.len].iter_mut()
         } else {
-            self.list[..self.len].iter_mut()
+            self.more.iter_mut()
         }
     }
 }
 
-impl<T: Copy> StaticVec<T> {
+impl<T: Default> StaticVec<T> {
-    /// Get the item at a particular index.
+    /// Get the item at a particular index, replacing it with the default.
     ///
     /// # Panics
     ///
     /// Panics if the index is out of bounds.
-    pub fn get(&self, index: usize) -> T {
+    pub fn get(&mut self, index: usize) -> T {
         if index >= self.len {
             panic!("index OOB in StaticVec");
         }
 
-        if self.len < self.list.len() {
+        mem::take(if self.len <= self.list.len() {
-            *self.list.get(index).unwrap()
+            unsafe { mem::transmute(self.list.get_mut(index).unwrap()) }
         } else {
-            *self.more.get(index).unwrap()
+            self.more.get_mut(index).unwrap()
-        }
+        })
     }
 }
 
@@ -230,20 +331,61 @@ impl<T: fmt::Debug> fmt::Debug for StaticVec<T> {
 
 impl<T> AsRef<[T]> for StaticVec<T> {
     fn as_ref(&self) -> &[T] {
-        if self.len > self.list.len() {
+        let list: &[T; MAX_STATIC_VEC] = unsafe { mem::transmute(&self.list) };
-            &self.more[..]
+
+        if self.len <= list.len() {
+            &list[..self.len]
         } else {
-            &self.list[..self.len]
+            &self.more[..]
         }
     }
 }
 
 impl<T> AsMut<[T]> for StaticVec<T> {
     fn as_mut(&mut self) -> &mut [T] {
-        if self.len > self.list.len() {
+        let list: &mut [T; MAX_STATIC_VEC] = unsafe { mem::transmute(&mut self.list) };
-            &mut self.more[..]
+
+        if self.len <= list.len() {
+            &mut list[..self.len]
         } else {
-            &mut self.list[..self.len]
+            &mut self.more[..]
         }
     }
 }
+
+impl<T> From<StaticVec<T>> for Vec<T> {
+    fn from(mut value: StaticVec<T>) -> Self {
+        if value.len <= value.list.len() {
+            value
+                .list
+                .iter_mut()
+                .map(|v| mem::replace(v, mem::MaybeUninit::uninit()))
+                .map(StaticVec::extract)
+                .collect()
+        } else {
+            let mut arr = Self::new();
+            arr.append(&mut value.more);
+            arr
+        }
+    }
+}
+
+impl<T> From<Vec<T>> for StaticVec<T> {
+    fn from(mut value: Vec<T>) -> Self {
+        let mut arr: Self = Default::default();
+        arr.len = value.len();
+
+        if arr.len <= arr.list.len() {
+            for x in (0..arr.len).rev() {
+                mem::replace(
+                    arr.list.get_mut(x).unwrap(),
+                    mem::MaybeUninit::new(value.pop().unwrap()),
+                );
+            }
+        } else {
+            arr.more = value;
+        }
+
+        arr
+    }
+}