2020-07-23 12:40:42 +02:00
|
|
|
//! Module implementing the AST optimizer.
|
|
|
|
|
2020-04-12 17:00:06 +02:00
|
|
|
use crate::any::Dynamic;
|
2020-04-21 17:01:10 +02:00
|
|
|
use crate::calc_fn_hash;
|
2020-07-19 11:14:55 +02:00
|
|
|
use crate::engine::{
|
|
|
|
Engine, Imports, KEYWORD_DEBUG, KEYWORD_EVAL, KEYWORD_FN_PTR, KEYWORD_PRINT, KEYWORD_TYPE_OF,
|
|
|
|
};
|
2020-06-05 09:14:42 +02:00
|
|
|
use crate::module::Module;
|
2020-07-10 16:01:47 +02:00
|
|
|
use crate::parser::{map_dynamic_to_expr, Expr, ReturnType, ScriptFnDef, Stmt, AST};
|
2020-03-25 04:27:18 +01:00
|
|
|
use crate::scope::{Entry as ScopeEntry, EntryType as ScopeEntryType, Scope};
|
2020-07-19 11:14:55 +02:00
|
|
|
use crate::token::is_valid_identifier;
|
2020-05-16 18:24:07 +02:00
|
|
|
use crate::utils::StaticVec;
|
2020-03-09 14:57:07 +01:00
|
|
|
|
2020-07-10 16:01:47 +02:00
|
|
|
#[cfg(feature = "internals")]
|
|
|
|
use crate::parser::CustomExpr;
|
|
|
|
|
2020-03-17 19:26:11 +01:00
|
|
|
use crate::stdlib::{
|
2020-03-18 11:41:18 +01:00
|
|
|
boxed::Box,
|
2020-05-07 18:19:08 +02:00
|
|
|
iter::empty,
|
2020-03-18 11:41:18 +01:00
|
|
|
string::{String, ToString},
|
|
|
|
vec,
|
|
|
|
vec::Vec,
|
2020-03-17 19:26:11 +01:00
|
|
|
};
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Level of optimization performed.
|
2020-04-03 13:42:01 +02:00
|
|
|
///
|
|
|
|
/// Not available under the `no_optimize` feature.
|
2020-03-15 15:39:58 +01:00
|
|
|
#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
|
|
|
|
pub enum OptimizationLevel {
|
2020-03-18 03:36:50 +01:00
|
|
|
/// No optimization performed.
|
2020-03-15 15:39:58 +01:00
|
|
|
None,
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Only perform simple optimizations without evaluating functions.
|
2020-03-15 15:39:58 +01:00
|
|
|
Simple,
|
|
|
|
/// Full optimizations performed, including evaluating functions.
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Take care that this may cause side effects as it essentially assumes that all functions are pure.
|
2020-03-15 15:39:58 +01:00
|
|
|
Full,
|
|
|
|
}
|
|
|
|
|
2020-04-10 06:16:39 +02:00
|
|
|
impl OptimizationLevel {
|
|
|
|
/// Is the `OptimizationLevel` None.
|
|
|
|
pub fn is_none(self) -> bool {
|
|
|
|
self == Self::None
|
|
|
|
}
|
2020-05-31 06:36:31 +02:00
|
|
|
/// Is the `OptimizationLevel` Simple.
|
|
|
|
pub fn is_simple(self) -> bool {
|
|
|
|
self == Self::Simple
|
|
|
|
}
|
2020-04-10 06:16:39 +02:00
|
|
|
/// Is the `OptimizationLevel` Full.
|
|
|
|
pub fn is_full(self) -> bool {
|
|
|
|
self == Self::Full
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Mutable state throughout an optimization pass.
|
2020-03-15 15:39:58 +01:00
|
|
|
struct State<'a> {
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Has the AST been changed during this pass?
|
2020-03-13 11:12:41 +01:00
|
|
|
changed: bool,
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Collection of constants to use for eager function evaluations.
|
2020-03-13 11:12:41 +01:00
|
|
|
constants: Vec<(String, Expr)>,
|
2020-03-18 03:36:50 +01:00
|
|
|
/// An `Engine` instance for eager function evaluation.
|
2020-04-16 17:31:48 +02:00
|
|
|
engine: &'a Engine,
|
2020-04-07 07:23:06 +02:00
|
|
|
/// Library of script-defined functions.
|
2020-06-05 09:14:42 +02:00
|
|
|
lib: &'a Module,
|
2020-04-08 03:30:50 +02:00
|
|
|
/// Optimization level.
|
|
|
|
optimization_level: OptimizationLevel,
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
|
|
|
|
2020-04-01 03:51:33 +02:00
|
|
|
impl<'a> State<'a> {
|
|
|
|
/// Create a new State.
|
2020-06-05 09:14:42 +02:00
|
|
|
pub fn new(engine: &'a Engine, lib: &'a Module, level: OptimizationLevel) -> Self {
|
2020-04-01 03:51:33 +02:00
|
|
|
Self {
|
|
|
|
changed: false,
|
|
|
|
constants: vec![],
|
|
|
|
engine,
|
2020-05-24 10:40:00 +02:00
|
|
|
lib,
|
2020-04-08 03:30:50 +02:00
|
|
|
optimization_level: level,
|
2020-04-01 03:51:33 +02:00
|
|
|
}
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Reset the state from dirty to clean.
|
2020-03-15 15:39:58 +01:00
|
|
|
pub fn reset(&mut self) {
|
|
|
|
self.changed = false;
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Set the AST state to be dirty (i.e. changed).
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn set_dirty(&mut self) {
|
|
|
|
self.changed = true;
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Is the AST dirty (i.e. changed)?
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn is_dirty(&self) -> bool {
|
|
|
|
self.changed
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Does a constant exist?
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn contains_constant(&self, name: &str) -> bool {
|
|
|
|
self.constants.iter().any(|(n, _)| n == name)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Prune the list of constants back to a specified size.
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn restore_constants(&mut self, len: usize) {
|
|
|
|
self.constants.truncate(len)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Add a new constant to the list.
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn push_constant(&mut self, name: &str, value: Expr) {
|
2020-05-11 17:48:50 +02:00
|
|
|
self.constants.push((name.into(), value))
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Look up a constant from the list.
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn find_constant(&self, name: &str) -> Option<&Expr> {
|
|
|
|
for (n, expr) in self.constants.iter().rev() {
|
|
|
|
if n == name {
|
|
|
|
return Some(expr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-09 12:45:49 +02:00
|
|
|
/// Call a registered function
|
2020-05-24 05:57:46 +02:00
|
|
|
fn call_fn_with_constant_arguments(
|
2020-05-23 12:59:28 +02:00
|
|
|
state: &State,
|
2020-04-09 12:45:49 +02:00
|
|
|
fn_name: &str,
|
2020-05-24 05:57:46 +02:00
|
|
|
arg_values: &mut [Dynamic],
|
2020-06-01 09:25:22 +02:00
|
|
|
) -> Option<Dynamic> {
|
2020-04-09 12:45:49 +02:00
|
|
|
// Search built-in's and external functions
|
2020-05-19 14:07:51 +02:00
|
|
|
let hash_fn = calc_fn_hash(
|
|
|
|
empty(),
|
|
|
|
fn_name,
|
2020-05-24 05:57:46 +02:00
|
|
|
arg_values.len(),
|
|
|
|
arg_values.iter().map(|a| a.type_id()),
|
2020-05-19 14:07:51 +02:00
|
|
|
);
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-05-23 12:59:28 +02:00
|
|
|
state
|
|
|
|
.engine
|
|
|
|
.call_fn_raw(
|
2020-05-30 04:27:48 +02:00
|
|
|
&mut Scope::new(),
|
2020-06-27 17:56:24 +02:00
|
|
|
&mut Imports::new(),
|
2020-05-24 10:40:00 +02:00
|
|
|
&mut Default::default(),
|
|
|
|
state.lib,
|
2020-05-23 12:59:28 +02:00
|
|
|
fn_name,
|
|
|
|
(hash_fn, 0),
|
2020-05-24 05:57:46 +02:00
|
|
|
arg_values.iter_mut().collect::<StaticVec<_>>().as_mut(),
|
|
|
|
false,
|
2020-06-26 04:39:18 +02:00
|
|
|
false,
|
2020-05-23 12:59:28 +02:00
|
|
|
None,
|
|
|
|
0,
|
|
|
|
)
|
|
|
|
.map(|(v, _)| Some(v))
|
2020-06-01 09:25:22 +02:00
|
|
|
.unwrap_or_else(|_| None)
|
2020-04-09 12:45:49 +02:00
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Optimize a statement.
|
2020-05-30 04:27:48 +02:00
|
|
|
fn optimize_stmt(stmt: Stmt, state: &mut State, preserve_result: bool) -> Stmt {
|
2020-03-09 14:57:07 +01:00
|
|
|
match stmt {
|
2020-03-18 03:36:50 +01:00
|
|
|
// if expr { Noop }
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::IfThenElse(x) if matches!(x.1, Stmt::Noop(_)) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-12 16:46:52 +01:00
|
|
|
|
2020-05-09 15:46:38 +02:00
|
|
|
let pos = x.0.position();
|
|
|
|
let expr = optimize_expr(x.0, state);
|
2020-03-12 16:46:52 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
if preserve_result {
|
|
|
|
// -> { expr, Noop }
|
2020-05-16 18:24:07 +02:00
|
|
|
let mut statements = StaticVec::new();
|
|
|
|
statements.push(Stmt::Expr(Box::new(expr)));
|
|
|
|
statements.push(x.1);
|
|
|
|
|
|
|
|
Stmt::Block(Box::new((statements, pos)))
|
2020-03-14 16:41:15 +01:00
|
|
|
} else {
|
2020-03-18 03:36:50 +01:00
|
|
|
// -> expr
|
|
|
|
Stmt::Expr(Box::new(expr))
|
2020-03-12 16:46:52 +01:00
|
|
|
}
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// if expr { if_block }
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::IfThenElse(x) if x.2.is_none() => match x.0 {
|
2020-03-18 03:36:50 +01:00
|
|
|
// if false { if_block } -> Noop
|
2020-03-09 14:57:07 +01:00
|
|
|
Expr::False(pos) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
Stmt::Noop(pos)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// if true { if_block } -> if_block
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::True(_) => optimize_stmt(x.1, state, true),
|
2020-03-18 03:36:50 +01:00
|
|
|
// if expr { if_block }
|
2020-05-09 15:46:38 +02:00
|
|
|
expr => Stmt::IfThenElse(Box::new((
|
|
|
|
optimize_expr(expr, state),
|
|
|
|
optimize_stmt(x.1, state, true),
|
2020-03-09 14:57:07 +01:00
|
|
|
None,
|
2020-05-09 15:46:38 +02:00
|
|
|
))),
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// if expr { if_block } else { else_block }
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::IfThenElse(x) if x.2.is_some() => match x.0 {
|
2020-03-18 03:36:50 +01:00
|
|
|
// if false { if_block } else { else_block } -> else_block
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::False(_) => optimize_stmt(x.2.unwrap(), state, true),
|
2020-03-18 03:36:50 +01:00
|
|
|
// if true { if_block } else { else_block } -> if_block
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::True(_) => optimize_stmt(x.1, state, true),
|
2020-03-18 03:36:50 +01:00
|
|
|
// if expr { if_block } else { else_block }
|
2020-05-09 15:46:38 +02:00
|
|
|
expr => Stmt::IfThenElse(Box::new((
|
|
|
|
optimize_expr(expr, state),
|
|
|
|
optimize_stmt(x.1, state, true),
|
|
|
|
match optimize_stmt(x.2.unwrap(), state, true) {
|
2020-04-23 07:24:24 +02:00
|
|
|
Stmt::Noop(_) => None, // Noop -> no else block
|
2020-05-09 15:46:38 +02:00
|
|
|
stmt => Some(stmt),
|
2020-03-12 16:46:52 +01:00
|
|
|
},
|
2020-05-09 15:46:38 +02:00
|
|
|
))),
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// while expr { block }
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::While(x) => match x.0 {
|
2020-03-18 03:36:50 +01:00
|
|
|
// while false { block } -> Noop
|
2020-03-09 14:57:07 +01:00
|
|
|
Expr::False(pos) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
Stmt::Noop(pos)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// while true { block } -> loop { block }
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::True(_) => Stmt::Loop(Box::new(optimize_stmt(x.1, state, false))),
|
2020-03-18 03:36:50 +01:00
|
|
|
// while expr { block }
|
2020-05-09 15:46:38 +02:00
|
|
|
expr => match optimize_stmt(x.1, state, false) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// while expr { break; } -> { expr; }
|
2020-03-17 10:33:37 +01:00
|
|
|
Stmt::Break(pos) => {
|
|
|
|
// Only a single break statement - turn into running the guard expression once
|
|
|
|
state.set_dirty();
|
2020-05-16 18:24:07 +02:00
|
|
|
let mut statements = StaticVec::new();
|
|
|
|
statements.push(Stmt::Expr(Box::new(optimize_expr(expr, state))));
|
2020-03-17 10:33:37 +01:00
|
|
|
if preserve_result {
|
|
|
|
statements.push(Stmt::Noop(pos))
|
|
|
|
}
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::Block(Box::new((statements, pos)))
|
2020-03-17 10:33:37 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// while expr { block }
|
2020-05-09 15:46:38 +02:00
|
|
|
stmt => Stmt::While(Box::new((optimize_expr(expr, state), stmt))),
|
2020-03-17 10:33:37 +01:00
|
|
|
},
|
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// loop { block }
|
|
|
|
Stmt::Loop(block) => match optimize_stmt(*block, state, false) {
|
|
|
|
// loop { break; } -> Noop
|
2020-03-17 10:33:37 +01:00
|
|
|
Stmt::Break(pos) => {
|
|
|
|
// Only a single break statement
|
|
|
|
state.set_dirty();
|
|
|
|
Stmt::Noop(pos)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// loop { block }
|
2020-03-17 10:33:37 +01:00
|
|
|
stmt => Stmt::Loop(Box::new(stmt)),
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// for id in expr { block }
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::For(x) => Stmt::For(Box::new((
|
|
|
|
x.0,
|
|
|
|
optimize_expr(x.1, state),
|
|
|
|
optimize_stmt(x.2, state, false),
|
|
|
|
))),
|
2020-03-18 03:36:50 +01:00
|
|
|
// let id = expr;
|
2020-05-09 18:19:13 +02:00
|
|
|
Stmt::Let(x) if x.1.is_some() => {
|
|
|
|
Stmt::Let(Box::new((x.0, Some(optimize_expr(x.1.unwrap(), state)))))
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// let id;
|
2020-05-09 15:46:38 +02:00
|
|
|
stmt @ Stmt::Let(_) => stmt,
|
2020-05-05 04:39:12 +02:00
|
|
|
// import expr as id;
|
2020-05-09 18:19:13 +02:00
|
|
|
Stmt::Import(x) => Stmt::Import(Box::new((optimize_expr(x.0, state), x.1))),
|
2020-03-18 03:36:50 +01:00
|
|
|
// { block }
|
2020-05-17 16:19:49 +02:00
|
|
|
Stmt::Block(x) => {
|
2020-05-09 15:46:38 +02:00
|
|
|
let orig_len = x.0.len(); // Original number of statements in the block, for change detection
|
2020-03-18 03:36:50 +01:00
|
|
|
let orig_constants_len = state.constants.len(); // Original number of constants in the state, for restore later
|
2020-05-09 15:46:38 +02:00
|
|
|
let pos = x.1;
|
2020-03-09 14:57:07 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Optimize each statement in the block
|
2020-05-09 15:46:38 +02:00
|
|
|
let mut result: Vec<_> =
|
2020-05-17 16:19:49 +02:00
|
|
|
x.0.into_iter()
|
2020-05-09 15:46:38 +02:00
|
|
|
.map(|stmt| match stmt {
|
|
|
|
// Add constant into the state
|
|
|
|
Stmt::Const(v) => {
|
2020-05-17 16:19:49 +02:00
|
|
|
let ((name, pos), expr) = *v;
|
|
|
|
state.push_constant(&name, expr);
|
2020-05-09 15:46:38 +02:00
|
|
|
state.set_dirty();
|
2020-05-17 16:19:49 +02:00
|
|
|
Stmt::Noop(pos) // No need to keep constants
|
2020-05-09 15:46:38 +02:00
|
|
|
}
|
|
|
|
// Optimize the statement
|
2020-05-17 16:19:49 +02:00
|
|
|
_ => optimize_stmt(stmt, state, preserve_result),
|
2020-05-09 15:46:38 +02:00
|
|
|
})
|
|
|
|
.collect();
|
2020-03-09 14:57:07 +01:00
|
|
|
|
2020-03-11 16:43:10 +01:00
|
|
|
// Remove all raw expression statements that are pure except for the very last statement
|
|
|
|
let last_stmt = if preserve_result { result.pop() } else { None };
|
2020-03-10 04:22:41 +01:00
|
|
|
|
2020-03-17 10:33:37 +01:00
|
|
|
result.retain(|stmt| !stmt.is_pure());
|
2020-03-11 16:43:10 +01:00
|
|
|
|
|
|
|
if let Some(stmt) = last_stmt {
|
|
|
|
result.push(stmt);
|
|
|
|
}
|
|
|
|
|
2020-05-05 04:39:12 +02:00
|
|
|
// Remove all let/import statements at the end of a block - the new variables will go away anyway.
|
2020-03-11 16:43:10 +01:00
|
|
|
// But be careful only remove ones that have no initial values or have values that are pure expressions,
|
|
|
|
// otherwise there may be side effects.
|
|
|
|
let mut removed = false;
|
|
|
|
|
|
|
|
while let Some(expr) = result.pop() {
|
|
|
|
match expr {
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::Let(x) if x.1.is_none() => removed = true,
|
|
|
|
Stmt::Let(x) if x.1.is_some() => removed = x.1.unwrap().is_pure(),
|
|
|
|
Stmt::Import(x) => removed = x.0.is_pure(),
|
2020-03-11 16:43:10 +01:00
|
|
|
_ => {
|
|
|
|
result.push(expr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if preserve_result {
|
|
|
|
if removed {
|
|
|
|
result.push(Stmt::Noop(pos))
|
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Optimize all the statements again
|
2020-03-11 16:43:10 +01:00
|
|
|
result = result
|
|
|
|
.into_iter()
|
|
|
|
.rev()
|
|
|
|
.enumerate()
|
2020-03-18 03:36:50 +01:00
|
|
|
.map(|(i, s)| optimize_stmt(s, state, i == 0))
|
2020-03-11 16:43:10 +01:00
|
|
|
.rev()
|
|
|
|
.collect();
|
2020-03-10 04:22:41 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 10:33:37 +01:00
|
|
|
// Remove everything following the the first return/throw
|
|
|
|
let mut dead_code = false;
|
|
|
|
|
|
|
|
result.retain(|stmt| {
|
|
|
|
if dead_code {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
match stmt {
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::ReturnWithVal(_) | Stmt::Break(_) => {
|
2020-03-17 10:33:37 +01:00
|
|
|
dead_code = true;
|
|
|
|
}
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
|
|
|
|
true
|
|
|
|
});
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Change detection
|
2020-03-13 11:12:41 +01:00
|
|
|
if orig_len != result.len() {
|
|
|
|
state.set_dirty();
|
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Pop the stack and remove all the local constants
|
2020-03-15 15:39:58 +01:00
|
|
|
state.restore_constants(orig_constants_len);
|
2020-03-09 14:57:07 +01:00
|
|
|
|
|
|
|
match result[..] {
|
2020-03-11 16:43:10 +01:00
|
|
|
// No statements in block - change to No-op
|
2020-03-09 14:57:07 +01:00
|
|
|
[] => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-10 04:22:41 +01:00
|
|
|
Stmt::Noop(pos)
|
|
|
|
}
|
2020-05-05 04:39:12 +02:00
|
|
|
// Only one let/import statement - leave it alone
|
2020-05-16 18:24:07 +02:00
|
|
|
[Stmt::Let(_)] | [Stmt::Import(_)] => Stmt::Block(Box::new((result.into(), pos))),
|
2020-03-11 16:43:10 +01:00
|
|
|
// Only one statement - promote
|
2020-03-09 14:57:07 +01:00
|
|
|
[_] => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
result.remove(0)
|
|
|
|
}
|
2020-05-16 18:24:07 +02:00
|
|
|
_ => Stmt::Block(Box::new((result.into(), pos))),
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// expr;
|
2020-03-13 11:12:41 +01:00
|
|
|
Stmt::Expr(expr) => Stmt::Expr(Box::new(optimize_expr(*expr, state))),
|
2020-03-18 03:36:50 +01:00
|
|
|
// return expr;
|
2020-05-09 18:19:13 +02:00
|
|
|
Stmt::ReturnWithVal(x) if x.1.is_some() => {
|
|
|
|
Stmt::ReturnWithVal(Box::new((x.0, Some(optimize_expr(x.1.unwrap(), state)))))
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// All other statements - skip
|
2020-03-11 16:43:10 +01:00
|
|
|
stmt => stmt,
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Optimize an expression.
|
2020-05-30 04:27:48 +02:00
|
|
|
fn optimize_expr(expr: Expr, state: &mut State) -> Expr {
|
2020-03-18 03:36:50 +01:00
|
|
|
// These keywords are handled specially
|
2020-03-19 12:53:42 +01:00
|
|
|
const DONT_EVAL_KEYWORDS: [&str; 3] = [KEYWORD_PRINT, KEYWORD_DEBUG, KEYWORD_EVAL];
|
2020-03-17 03:27:43 +01:00
|
|
|
|
2020-03-09 14:57:07 +01:00
|
|
|
match expr {
|
2020-05-30 04:27:48 +02:00
|
|
|
// expr - do not promote because there is a reason it is wrapped in an `Expr::Expr`
|
|
|
|
Expr::Expr(x) => Expr::Expr(Box::new(optimize_expr(*x, state))),
|
2020-03-18 03:36:50 +01:00
|
|
|
// ( stmt )
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::Stmt(x) => match optimize_stmt(x.0, state, true) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// ( Noop ) -> ()
|
2020-03-09 14:57:07 +01:00
|
|
|
Stmt::Noop(_) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::Unit(x.1)
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// ( expr ) -> expr
|
2020-03-09 14:57:07 +01:00
|
|
|
Stmt::Expr(expr) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
*expr
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// ( stmt )
|
2020-05-09 15:46:38 +02:00
|
|
|
stmt => Expr::Stmt(Box::new((stmt, x.1))),
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-05-31 17:44:49 +02:00
|
|
|
// id op= expr
|
2020-07-05 17:07:02 +02:00
|
|
|
Expr::Assignment(x) => Expr::Assignment(Box::new((x.0, x.1, optimize_expr(x.2, state), x.3))),
|
2020-04-10 15:02:13 +02:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs.rhs
|
2020-03-29 11:15:12 +02:00
|
|
|
#[cfg(not(feature = "no_object"))]
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::Dot(x) => match (x.0, x.1) {
|
2020-04-10 15:02:13 +02:00
|
|
|
// map.string
|
2020-05-17 16:19:49 +02:00
|
|
|
(Expr::Map(m), Expr::Property(p)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
|
2020-05-13 04:19:18 +02:00
|
|
|
let ((prop, _, _), _) = p.as_ref();
|
2020-04-10 15:02:13 +02:00
|
|
|
// Map literal where everything is pure - promote the indexed item.
|
|
|
|
// All other items can be thrown away.
|
|
|
|
state.set_dirty();
|
2020-05-09 15:46:38 +02:00
|
|
|
let pos = m.1;
|
2020-07-21 14:59:12 +02:00
|
|
|
m.0.into_iter().find(|((name, _), _)| name.as_str() == prop.as_str())
|
2020-05-17 16:19:49 +02:00
|
|
|
.map(|(_, expr)| expr.set_position(pos))
|
2020-04-10 15:02:13 +02:00
|
|
|
.unwrap_or_else(|| Expr::Unit(pos))
|
|
|
|
}
|
|
|
|
// lhs.rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
(lhs, rhs) => Expr::Dot(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2)))
|
2020-04-10 15:02:13 +02:00
|
|
|
}
|
2020-03-11 04:03:18 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs[rhs]
|
2020-03-10 10:10:33 +01:00
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::Index(x) => match (x.0, x.1) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// array[int]
|
2020-05-09 15:46:38 +02:00
|
|
|
(Expr::Array(mut a), Expr::IntegerConstant(i))
|
|
|
|
if i.0 >= 0 && (i.0 as usize) < a.0.len() && a.0.iter().all(Expr::is_pure) =>
|
2020-03-10 10:10:33 +01:00
|
|
|
{
|
2020-03-16 05:41:52 +01:00
|
|
|
// Array literal where everything is pure - promote the indexed item.
|
2020-03-11 16:43:10 +01:00
|
|
|
// All other items can be thrown away.
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-05-17 16:19:49 +02:00
|
|
|
a.0.take(i.0 as usize).set_position(a.1)
|
2020-04-10 15:02:13 +02:00
|
|
|
}
|
|
|
|
// map[string]
|
2020-05-17 16:19:49 +02:00
|
|
|
(Expr::Map(m), Expr::StringConstant(s)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
|
2020-04-10 15:02:13 +02:00
|
|
|
// Map literal where everything is pure - promote the indexed item.
|
|
|
|
// All other items can be thrown away.
|
|
|
|
state.set_dirty();
|
2020-05-09 15:46:38 +02:00
|
|
|
let pos = m.1;
|
2020-06-21 10:37:05 +02:00
|
|
|
m.0.into_iter().find(|((name, _), _)| *name == s.0)
|
2020-05-17 16:19:49 +02:00
|
|
|
.map(|(_, expr)| expr.set_position(pos))
|
2020-04-10 15:02:13 +02:00
|
|
|
.unwrap_or_else(|| Expr::Unit(pos))
|
2020-03-10 10:10:33 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// string[int]
|
2020-05-09 15:46:38 +02:00
|
|
|
(Expr::StringConstant(s), Expr::IntegerConstant(i)) if i.0 >= 0 && (i.0 as usize) < s.0.chars().count() => {
|
2020-03-16 05:41:52 +01:00
|
|
|
// String literal indexing - get the character
|
|
|
|
state.set_dirty();
|
2020-07-21 16:32:24 +02:00
|
|
|
Expr::CharConstant(Box::new((s.0.chars().nth(i.0 as usize).unwrap(), s.1)))
|
2020-03-16 05:41:52 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs[rhs]
|
2020-05-09 15:46:38 +02:00
|
|
|
(lhs, rhs) => Expr::Index(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))),
|
2020-03-10 10:10:33 +01:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// [ items .. ]
|
2020-03-10 10:10:33 +01:00
|
|
|
#[cfg(not(feature = "no_index"))]
|
2020-05-17 16:19:49 +02:00
|
|
|
Expr::Array(a) => Expr::Array(Box::new((a.0
|
|
|
|
.into_iter().map(|expr| optimize_expr(expr, state))
|
2020-05-16 18:24:07 +02:00
|
|
|
.collect(), a.1))),
|
2020-03-29 17:53:35 +02:00
|
|
|
// [ items .. ]
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
2020-05-17 16:19:49 +02:00
|
|
|
Expr::Map(m) => Expr::Map(Box::new((m.0
|
|
|
|
.into_iter().map(|((key, pos), expr)| ((key, pos), optimize_expr(expr, state)))
|
2020-05-09 15:46:38 +02:00
|
|
|
.collect(), m.1))),
|
2020-04-06 11:47:34 +02:00
|
|
|
// lhs in rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::In(x) => match (x.0, x.1) {
|
2020-04-06 11:47:34 +02:00
|
|
|
// "xxx" in "xxxxx"
|
2020-05-09 15:46:38 +02:00
|
|
|
(Expr::StringConstant(a), Expr::StringConstant(b)) => {
|
2020-04-06 11:47:34 +02:00
|
|
|
state.set_dirty();
|
2020-07-25 08:06:13 +02:00
|
|
|
if b.0.contains(a.0.as_str()) { Expr::True(a.1) } else { Expr::False(a.1) }
|
2020-04-06 11:47:34 +02:00
|
|
|
}
|
|
|
|
// 'x' in "xxxxx"
|
2020-05-09 15:46:38 +02:00
|
|
|
(Expr::CharConstant(a), Expr::StringConstant(b)) => {
|
2020-04-06 11:47:34 +02:00
|
|
|
state.set_dirty();
|
2020-05-09 15:46:38 +02:00
|
|
|
if b.0.contains(a.0) { Expr::True(a.1) } else { Expr::False(a.1) }
|
2020-04-06 11:47:34 +02:00
|
|
|
}
|
|
|
|
// "xxx" in #{...}
|
2020-05-09 15:46:38 +02:00
|
|
|
(Expr::StringConstant(a), Expr::Map(b)) => {
|
2020-04-06 11:47:34 +02:00
|
|
|
state.set_dirty();
|
2020-06-21 10:37:05 +02:00
|
|
|
if b.0.iter().find(|((name, _), _)| *name == a.0).is_some() {
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::True(a.1)
|
2020-04-06 11:47:34 +02:00
|
|
|
} else {
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::False(a.1)
|
2020-04-06 11:47:34 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// 'x' in #{...}
|
2020-05-09 15:46:38 +02:00
|
|
|
(Expr::CharConstant(a), Expr::Map(b)) => {
|
2020-04-06 11:47:34 +02:00
|
|
|
state.set_dirty();
|
2020-05-09 15:46:38 +02:00
|
|
|
let ch = a.0.to_string();
|
2020-04-06 11:47:34 +02:00
|
|
|
|
2020-06-21 10:37:05 +02:00
|
|
|
if b.0.iter().find(|((name, _), _)| name.as_str() == ch.as_str()).is_some() {
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::True(a.1)
|
2020-04-06 11:47:34 +02:00
|
|
|
} else {
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::False(a.1)
|
2020-04-06 11:47:34 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// lhs in rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
(lhs, rhs) => Expr::In(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))),
|
2020-04-06 11:47:34 +02:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs && rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::And(x) => match (x.0, x.1) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// true && rhs -> rhs
|
2020-03-09 14:57:07 +01:00
|
|
|
(Expr::True(_), rhs) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
rhs
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// false && rhs -> false
|
2020-03-09 14:57:07 +01:00
|
|
|
(Expr::False(pos), _) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
Expr::False(pos)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs && true -> lhs
|
2020-03-09 14:57:07 +01:00
|
|
|
(lhs, Expr::True(_)) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-18 03:36:50 +01:00
|
|
|
optimize_expr(lhs, state)
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs && rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
(lhs, rhs) => Expr::And(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))),
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs || rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::Or(x) => match (x.0, x.1) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// false || rhs -> rhs
|
2020-03-09 14:57:07 +01:00
|
|
|
(Expr::False(_), rhs) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
rhs
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// true || rhs -> true
|
2020-03-09 14:57:07 +01:00
|
|
|
(Expr::True(pos), _) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-09 14:57:07 +01:00
|
|
|
Expr::True(pos)
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs || false
|
2020-03-09 14:57:07 +01:00
|
|
|
(lhs, Expr::False(_)) => {
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-18 03:36:50 +01:00
|
|
|
optimize_expr(lhs, state)
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs || rhs
|
2020-05-09 15:46:38 +02:00
|
|
|
(lhs, rhs) => Expr::Or(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))),
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-11 16:43:10 +01:00
|
|
|
|
2020-04-01 03:51:33 +02:00
|
|
|
// Do not call some special keywords
|
2020-05-09 18:19:13 +02:00
|
|
|
Expr::FnCall(mut x) if DONT_EVAL_KEYWORDS.contains(&(x.0).0.as_ref())=> {
|
2020-05-17 16:19:49 +02:00
|
|
|
x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::FnCall(x)
|
|
|
|
}
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2020-07-19 11:14:55 +02:00
|
|
|
// Fn("...")
|
|
|
|
Expr::FnCall(x)
|
|
|
|
if x.1.is_none()
|
|
|
|
&& (x.0).0 == KEYWORD_FN_PTR
|
|
|
|
&& x.3.len() == 1
|
|
|
|
&& matches!(x.3[0], Expr::StringConstant(_))
|
|
|
|
=> {
|
|
|
|
match &x.3[0] {
|
|
|
|
Expr::StringConstant(s) if is_valid_identifier(s.0.chars()) => Expr::FnPointer(s.clone()),
|
|
|
|
_ => Expr::FnCall(x)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Eagerly call functions
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::FnCall(mut x)
|
|
|
|
if x.1.is_none() // Non-qualified
|
|
|
|
&& state.optimization_level == OptimizationLevel::Full // full optimizations
|
|
|
|
&& x.3.iter().all(|expr| expr.is_constant()) // all arguments are constants
|
2020-03-17 03:27:43 +01:00
|
|
|
=> {
|
2020-06-05 09:14:42 +02:00
|
|
|
let ((name, _, pos), _, _, args, def_value) = x.as_mut();
|
2020-05-09 18:19:13 +02:00
|
|
|
|
2020-06-05 09:14:42 +02:00
|
|
|
// First search in functions lib (can override built-in)
|
2020-05-24 05:57:46 +02:00
|
|
|
// Cater for both normal function call style and method call style (one additional arguments)
|
2020-07-04 10:21:15 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
let has_script_fn = state.lib.iter_fn().find(|(_, _, _, f)| {
|
2020-06-05 09:14:42 +02:00
|
|
|
if !f.is_script() { return false; }
|
|
|
|
let fn_def = f.get_fn_def();
|
2020-07-25 08:06:13 +02:00
|
|
|
fn_def.name.as_str() == name && (args.len()..=args.len() + 1).contains(&fn_def.params.len())
|
2020-07-04 10:21:15 +02:00
|
|
|
}).is_some();
|
|
|
|
|
|
|
|
#[cfg(feature = "no_function")]
|
|
|
|
const has_script_fn: bool = false;
|
|
|
|
|
|
|
|
if has_script_fn {
|
2020-04-07 07:23:06 +02:00
|
|
|
// A script-defined function overrides the built-in function - do not make the call
|
2020-05-17 16:19:49 +02:00
|
|
|
x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
|
2020-05-09 15:46:38 +02:00
|
|
|
return Expr::FnCall(x);
|
2020-03-19 15:29:02 +01:00
|
|
|
}
|
|
|
|
|
2020-05-17 16:19:49 +02:00
|
|
|
let mut arg_values: StaticVec<_> = args.iter().map(Expr::get_constant_value).collect();
|
2020-03-17 03:27:43 +01:00
|
|
|
|
|
|
|
// Save the typename of the first argument if it is `type_of()`
|
|
|
|
// This is to avoid `call_args` being passed into the closure
|
2020-05-24 05:57:46 +02:00
|
|
|
let arg_for_type_of = if name == KEYWORD_TYPE_OF && arg_values.len() == 1 {
|
|
|
|
state.engine.map_type_name(arg_values[0].type_name())
|
2020-03-17 03:27:43 +01:00
|
|
|
} else {
|
|
|
|
""
|
|
|
|
};
|
|
|
|
|
2020-06-01 09:25:22 +02:00
|
|
|
call_fn_with_constant_arguments(&state, name, arg_values.as_mut())
|
|
|
|
.or_else(|| {
|
|
|
|
if !arg_for_type_of.is_empty() {
|
|
|
|
// Handle `type_of()`
|
|
|
|
Some(arg_for_type_of.to_string().into())
|
|
|
|
} else {
|
|
|
|
// Otherwise use the default value, if any
|
2020-07-19 11:14:55 +02:00
|
|
|
def_value.map(|v| v.into())
|
2020-06-01 09:25:22 +02:00
|
|
|
}
|
|
|
|
})
|
|
|
|
.and_then(|result| map_dynamic_to_expr(result, *pos))
|
|
|
|
.map(|expr| {
|
|
|
|
state.set_dirty();
|
|
|
|
expr
|
|
|
|
})
|
|
|
|
.unwrap_or_else(|| {
|
2020-04-09 12:45:49 +02:00
|
|
|
// Optimize function call arguments
|
2020-05-17 16:19:49 +02:00
|
|
|
x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::FnCall(x)
|
|
|
|
})
|
2020-03-15 15:39:58 +01:00
|
|
|
}
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// id(args ..) -> optimize function call arguments
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::FnCall(mut x) => {
|
2020-05-17 16:19:49 +02:00
|
|
|
x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect();
|
2020-05-09 15:46:38 +02:00
|
|
|
Expr::FnCall(x)
|
|
|
|
}
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// constant-name
|
2020-05-09 18:19:13 +02:00
|
|
|
Expr::Variable(x) if x.1.is_none() && state.contains_constant(&(x.0).0) => {
|
|
|
|
let (name, pos) = x.0;
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
|
|
|
|
|
|
|
// Replace constant with value
|
2020-07-21 16:32:24 +02:00
|
|
|
state.find_constant(&name).unwrap().clone().set_position(pos)
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2020-07-09 13:54:28 +02:00
|
|
|
// Custom syntax
|
2020-07-10 16:01:47 +02:00
|
|
|
#[cfg(feature = "internals")]
|
2020-07-09 13:54:28 +02:00
|
|
|
Expr::Custom(x) => Expr::Custom(Box::new((
|
|
|
|
CustomExpr(
|
|
|
|
(x.0).0.into_iter().map(|expr| optimize_expr(expr, state)).collect(),
|
|
|
|
(x.0).1),
|
|
|
|
x.1
|
|
|
|
))),
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// All other expressions - skip
|
2020-03-11 16:43:10 +01:00
|
|
|
expr => expr,
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-24 10:40:00 +02:00
|
|
|
fn optimize(
|
2020-04-07 07:23:06 +02:00
|
|
|
statements: Vec<Stmt>,
|
2020-04-16 17:31:48 +02:00
|
|
|
engine: &Engine,
|
2020-04-07 07:23:06 +02:00
|
|
|
scope: &Scope,
|
2020-06-05 09:14:42 +02:00
|
|
|
lib: &Module,
|
2020-04-08 03:30:50 +02:00
|
|
|
level: OptimizationLevel,
|
2020-04-07 07:23:06 +02:00
|
|
|
) -> Vec<Stmt> {
|
2020-03-15 15:39:58 +01:00
|
|
|
// If optimization level is None then skip optimizing
|
2020-04-08 03:30:50 +02:00
|
|
|
if level == OptimizationLevel::None {
|
2020-03-15 15:39:58 +01:00
|
|
|
return statements;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set up the state
|
2020-05-24 10:40:00 +02:00
|
|
|
let mut state = State::new(engine, lib, level);
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Add constants from the scope into the state
|
2020-03-15 15:39:58 +01:00
|
|
|
scope
|
2020-06-25 05:07:46 +02:00
|
|
|
.to_iter()
|
2020-03-25 04:27:18 +01:00
|
|
|
.filter(|ScopeEntry { typ, expr, .. }| {
|
2020-03-15 15:39:58 +01:00
|
|
|
// Get all the constants with definite constant expressions
|
2020-03-25 04:27:18 +01:00
|
|
|
*typ == ScopeEntryType::Constant
|
2020-04-27 15:14:34 +02:00
|
|
|
&& expr.as_ref().map(|v| v.is_constant()).unwrap_or(false)
|
2020-03-15 15:39:58 +01:00
|
|
|
})
|
|
|
|
.for_each(|ScopeEntry { name, expr, .. }| {
|
2020-07-21 16:32:24 +02:00
|
|
|
state.push_constant(name.as_ref(), expr.as_ref().unwrap().as_ref().clone())
|
2020-03-15 15:39:58 +01:00
|
|
|
});
|
|
|
|
|
|
|
|
let orig_constants_len = state.constants.len();
|
|
|
|
|
2020-03-11 16:43:10 +01:00
|
|
|
let mut result = statements;
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Optimization loop
|
2020-03-09 14:57:07 +01:00
|
|
|
loop {
|
2020-03-15 15:39:58 +01:00
|
|
|
state.reset();
|
|
|
|
state.restore_constants(orig_constants_len);
|
2020-03-09 14:57:07 +01:00
|
|
|
|
2020-03-15 15:39:58 +01:00
|
|
|
let num_statements = result.len();
|
2020-03-14 07:30:44 +01:00
|
|
|
|
2020-03-11 16:43:10 +01:00
|
|
|
result = result
|
2020-03-09 14:57:07 +01:00
|
|
|
.into_iter()
|
2020-03-11 16:43:10 +01:00
|
|
|
.enumerate()
|
|
|
|
.map(|(i, stmt)| {
|
2020-05-09 15:46:38 +02:00
|
|
|
match &stmt {
|
2020-05-09 18:19:13 +02:00
|
|
|
Stmt::Const(v) => {
|
2020-04-11 12:09:03 +02:00
|
|
|
// Load constants
|
2020-05-09 18:19:13 +02:00
|
|
|
let ((name, _), expr) = v.as_ref();
|
|
|
|
state.push_constant(&name, expr.clone());
|
2020-04-11 12:09:03 +02:00
|
|
|
stmt // Keep it in the global scope
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
// Keep all variable declarations at this level
|
|
|
|
// and always keep the last return value
|
2020-05-05 04:39:12 +02:00
|
|
|
let keep = match stmt {
|
2020-05-09 15:46:38 +02:00
|
|
|
Stmt::Let(_) | Stmt::Import(_) => true,
|
2020-05-05 04:39:12 +02:00
|
|
|
_ => i == num_statements - 1,
|
|
|
|
};
|
2020-04-11 12:09:03 +02:00
|
|
|
optimize_stmt(stmt, &mut state, keep)
|
|
|
|
}
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
2020-03-11 16:43:10 +01:00
|
|
|
})
|
2020-03-09 14:57:07 +01:00
|
|
|
.collect();
|
|
|
|
|
2020-03-13 11:12:41 +01:00
|
|
|
if !state.is_dirty() {
|
2020-03-09 14:57:07 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-12 16:46:52 +01:00
|
|
|
// Eliminate code that is pure but always keep the last statement
|
2020-03-11 16:43:10 +01:00
|
|
|
let last_stmt = result.pop();
|
|
|
|
|
2020-03-17 07:29:22 +01:00
|
|
|
// Remove all pure statements at global level
|
2020-03-18 11:41:18 +01:00
|
|
|
result.retain(|stmt| !stmt.is_pure());
|
2020-03-11 16:43:10 +01:00
|
|
|
|
2020-03-18 11:41:18 +01:00
|
|
|
// Add back the last statement unless it is a lone No-op
|
2020-03-11 16:43:10 +01:00
|
|
|
if let Some(stmt) = last_stmt {
|
2020-03-24 09:57:35 +01:00
|
|
|
if !result.is_empty() || !matches!(stmt, Stmt::Noop(_)) {
|
2020-03-18 11:41:18 +01:00
|
|
|
result.push(stmt);
|
|
|
|
}
|
2020-03-11 16:43:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
result
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Optimize an AST.
|
2020-03-18 11:41:18 +01:00
|
|
|
pub fn optimize_into_ast(
|
2020-03-15 15:39:58 +01:00
|
|
|
engine: &Engine,
|
|
|
|
scope: &Scope,
|
|
|
|
statements: Vec<Stmt>,
|
2020-06-05 09:14:42 +02:00
|
|
|
functions: Vec<ScriptFnDef>,
|
2020-04-08 03:30:50 +02:00
|
|
|
level: OptimizationLevel,
|
2020-03-15 15:39:58 +01:00
|
|
|
) -> AST {
|
2020-04-10 06:16:39 +02:00
|
|
|
#[cfg(feature = "no_optimize")]
|
|
|
|
const level: OptimizationLevel = OptimizationLevel::None;
|
|
|
|
|
2020-05-06 13:45:17 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-05-24 10:40:00 +02:00
|
|
|
let lib = {
|
2020-06-05 09:14:42 +02:00
|
|
|
let mut module = Module::new();
|
2020-05-10 15:25:47 +02:00
|
|
|
|
2020-06-05 09:14:42 +02:00
|
|
|
if !level.is_none() {
|
|
|
|
// We only need the script library's signatures for optimization purposes
|
|
|
|
let mut lib2 = Module::new();
|
|
|
|
|
|
|
|
functions
|
|
|
|
.iter()
|
|
|
|
.map(|fn_def| {
|
|
|
|
ScriptFnDef {
|
|
|
|
name: fn_def.name.clone(),
|
|
|
|
access: fn_def.access,
|
|
|
|
body: Default::default(),
|
|
|
|
params: fn_def.params.clone(),
|
|
|
|
pos: fn_def.pos,
|
2020-05-24 10:40:00 +02:00
|
|
|
}
|
2020-06-05 09:14:42 +02:00
|
|
|
.into()
|
|
|
|
})
|
2020-07-12 05:46:53 +02:00
|
|
|
.for_each(|fn_def| {
|
|
|
|
lib2.set_script_fn(fn_def);
|
|
|
|
});
|
2020-06-05 09:14:42 +02:00
|
|
|
|
|
|
|
functions
|
|
|
|
.into_iter()
|
|
|
|
.map(|mut fn_def| {
|
|
|
|
let pos = fn_def.body.position();
|
|
|
|
|
|
|
|
// Optimize the function body
|
|
|
|
let mut body = optimize(vec![fn_def.body], engine, &Scope::new(), &lib2, level);
|
|
|
|
|
|
|
|
// {} -> Noop
|
|
|
|
fn_def.body = match body.pop().unwrap_or_else(|| Stmt::Noop(pos)) {
|
|
|
|
// { return val; } -> val
|
|
|
|
Stmt::ReturnWithVal(x)
|
|
|
|
if x.1.is_some() && (x.0).0 == ReturnType::Return =>
|
|
|
|
{
|
|
|
|
Stmt::Expr(Box::new(x.1.unwrap()))
|
|
|
|
}
|
|
|
|
// { return; } -> ()
|
|
|
|
Stmt::ReturnWithVal(x)
|
|
|
|
if x.1.is_none() && (x.0).0 == ReturnType::Return =>
|
|
|
|
{
|
|
|
|
Stmt::Expr(Box::new(Expr::Unit((x.0).1)))
|
|
|
|
}
|
|
|
|
// All others
|
|
|
|
stmt => stmt,
|
|
|
|
};
|
|
|
|
fn_def.into()
|
|
|
|
})
|
2020-07-12 05:46:53 +02:00
|
|
|
.for_each(|fn_def| {
|
|
|
|
module.set_script_fn(fn_def);
|
|
|
|
});
|
2020-05-24 10:40:00 +02:00
|
|
|
} else {
|
2020-07-12 05:46:53 +02:00
|
|
|
functions.into_iter().for_each(|fn_def| {
|
|
|
|
module.set_script_fn(fn_def);
|
|
|
|
});
|
2020-05-10 15:25:47 +02:00
|
|
|
}
|
2020-06-05 09:14:42 +02:00
|
|
|
|
|
|
|
module
|
2020-05-24 10:40:00 +02:00
|
|
|
};
|
2020-04-04 16:00:44 +02:00
|
|
|
|
2020-05-06 13:45:17 +02:00
|
|
|
#[cfg(feature = "no_function")]
|
2020-06-05 09:14:42 +02:00
|
|
|
let lib = Default::default();
|
2020-05-06 13:45:17 +02:00
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
AST::new(
|
2020-04-08 03:30:50 +02:00
|
|
|
match level {
|
2020-04-04 16:00:44 +02:00
|
|
|
OptimizationLevel::None => statements,
|
|
|
|
OptimizationLevel::Simple | OptimizationLevel::Full => {
|
2020-05-24 10:40:00 +02:00
|
|
|
optimize(statements, engine, &scope, &lib, level)
|
2020-04-04 16:00:44 +02:00
|
|
|
}
|
|
|
|
},
|
2020-05-05 09:00:10 +02:00
|
|
|
lib,
|
2020-03-15 15:39:58 +01:00
|
|
|
)
|
|
|
|
}
|