2020-11-25 02:36:06 +01:00
|
|
|
//! Module implementing the [`AST`] optimizer.
|
2021-11-27 16:20:05 +01:00
|
|
|
#![cfg(not(feature = "no_optimize"))]
|
2020-07-23 12:40:42 +02:00
|
|
|
|
2022-02-25 04:42:59 +01:00
|
|
|
use crate::ast::{ASTFlags, Expr, OpAssignment, Stmt, StmtBlock, StmtBlockContainer, SwitchCases};
|
2022-01-07 04:43:47 +01:00
|
|
|
use crate::engine::{KEYWORD_DEBUG, KEYWORD_EVAL, KEYWORD_FN_PTR, KEYWORD_PRINT, KEYWORD_TYPE_OF};
|
|
|
|
use crate::eval::{EvalState, GlobalRuntimeState};
|
2021-11-13 15:36:23 +01:00
|
|
|
use crate::func::builtin::get_builtin_binary_op_fn;
|
|
|
|
use crate::func::hashing::get_hasher;
|
2022-02-08 16:01:47 +01:00
|
|
|
use crate::tokenizer::{Span, Token};
|
2021-11-13 15:36:23 +01:00
|
|
|
use crate::types::dynamic::AccessMode;
|
2021-12-27 15:28:11 +01:00
|
|
|
use crate::{
|
|
|
|
calc_fn_hash, calc_fn_params_hash, combine_hashes, Dynamic, Engine, FnPtr, Position, Scope,
|
|
|
|
StaticVec, AST, INT,
|
|
|
|
};
|
2021-04-17 09:15:54 +02:00
|
|
|
#[cfg(feature = "no_std")]
|
|
|
|
use std::prelude::v1::*;
|
|
|
|
use std::{
|
2021-12-27 15:28:11 +01:00
|
|
|
any::TypeId,
|
2021-12-02 05:49:57 +01:00
|
|
|
convert::TryFrom,
|
2021-04-17 09:15:54 +02:00
|
|
|
hash::{Hash, Hasher},
|
|
|
|
mem,
|
|
|
|
};
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Level of optimization performed.
|
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,
|
|
|
|
}
|
|
|
|
|
2021-05-18 06:24:11 +02:00
|
|
|
impl Default for OptimizationLevel {
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2021-05-18 06:24:11 +02:00
|
|
|
fn default() -> Self {
|
2021-11-29 03:17:04 +01:00
|
|
|
Self::Simple
|
2020-04-10 06:16:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Mutable state throughout an optimization pass.
|
2020-10-09 07:26:32 +02:00
|
|
|
#[derive(Debug, Clone)]
|
2021-07-04 10:40:15 +02:00
|
|
|
struct OptimizerState<'a> {
|
2020-11-25 02:36:06 +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.
|
2021-09-12 08:34:00 +02:00
|
|
|
variables: StaticVec<(String, AccessMode, Option<Dynamic>)>,
|
2021-01-12 16:52:50 +01:00
|
|
|
/// Activate constants propagation?
|
|
|
|
propagate_constants: bool,
|
2020-11-25 02:36:06 +01:00
|
|
|
/// An [`Engine`] instance for eager function evaluation.
|
2020-04-16 17:31:48 +02:00
|
|
|
engine: &'a Engine,
|
2021-11-29 02:43:35 +01:00
|
|
|
/// [Module][crate::Module] containing script-defined functions.
|
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
lib: &'a [&'a crate::Module],
|
2020-04-08 03:30:50 +02:00
|
|
|
/// Optimization level.
|
|
|
|
optimization_level: OptimizationLevel,
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
|
|
|
|
2021-07-04 10:40:15 +02:00
|
|
|
impl<'a> OptimizerState<'a> {
|
2020-04-01 03:51:33 +02:00
|
|
|
/// Create a new State.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2021-11-25 10:09:00 +01:00
|
|
|
pub const fn new(
|
2021-03-11 11:29:22 +01:00
|
|
|
engine: &'a Engine,
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))] lib: &'a [&'a crate::Module],
|
2021-03-11 11:29:22 +01:00
|
|
|
optimization_level: OptimizationLevel,
|
|
|
|
) -> Self {
|
2020-04-01 03:51:33 +02:00
|
|
|
Self {
|
|
|
|
changed: false,
|
2021-11-25 10:09:00 +01:00
|
|
|
variables: StaticVec::new_const(),
|
2021-01-12 16:52:50 +01:00
|
|
|
propagate_constants: true,
|
2020-04-01 03:51:33 +02:00
|
|
|
engine,
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-05-24 10:40:00 +02:00
|
|
|
lib,
|
2021-03-11 11:29:22 +01:00
|
|
|
optimization_level,
|
2020-04-01 03:51:33 +02:00
|
|
|
}
|
|
|
|
}
|
2020-11-25 02:36:06 +01:00
|
|
|
/// Set the [`AST`] state to be dirty (i.e. changed).
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-03-13 11:12:41 +01:00
|
|
|
pub fn set_dirty(&mut self) {
|
|
|
|
self.changed = true;
|
|
|
|
}
|
2021-03-11 11:29:22 +01:00
|
|
|
/// Set the [`AST`] state to be not dirty (i.e. unchanged).
|
|
|
|
#[inline(always)]
|
|
|
|
pub fn clear_dirty(&mut self) {
|
|
|
|
self.changed = false;
|
|
|
|
}
|
2020-11-25 02:36:06 +01:00
|
|
|
/// Is the [`AST`] dirty (i.e. changed)?
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2021-06-28 12:06:05 +02:00
|
|
|
pub const fn is_dirty(&self) -> bool {
|
2020-03-13 11:12:41 +01:00
|
|
|
self.changed
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
/// Prune the list of constants back to a specified size.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2020-12-08 15:20:29 +01:00
|
|
|
pub fn restore_var(&mut self, len: usize) {
|
|
|
|
self.variables.truncate(len)
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
2022-01-20 01:17:34 +01:00
|
|
|
/// Add a new variable to the list.
|
2020-10-08 16:25:50 +02:00
|
|
|
#[inline(always)]
|
2021-11-27 16:04:45 +01:00
|
|
|
pub fn push_var(
|
|
|
|
&mut self,
|
|
|
|
name: impl Into<String>,
|
|
|
|
access: AccessMode,
|
|
|
|
value: Option<Dynamic>,
|
|
|
|
) {
|
2020-12-08 15:20:29 +01:00
|
|
|
self.variables.push((name.into(), access, 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-10-08 16:25:50 +02:00
|
|
|
#[inline]
|
2022-01-04 08:22:48 +01:00
|
|
|
pub fn find_constant(&self, name: &str) -> Option<&Dynamic> {
|
2021-01-12 16:52:50 +01:00
|
|
|
if !self.propagate_constants {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2021-11-08 15:16:28 +01:00
|
|
|
for (n, access, value) in self.variables.iter().rev() {
|
2020-03-13 11:12:41 +01:00
|
|
|
if n == name {
|
2021-11-08 15:16:28 +01:00
|
|
|
return match access {
|
2021-03-05 06:34:58 +01:00
|
|
|
AccessMode::ReadWrite => None,
|
2021-05-16 15:21:13 +02:00
|
|
|
AccessMode::ReadOnly => value.as_ref(),
|
2021-11-08 15:16:28 +01:00
|
|
|
};
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
2021-11-08 15:16:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
None
|
2020-03-13 11:12:41 +01:00
|
|
|
}
|
2021-07-14 07:57:58 +02:00
|
|
|
/// Call a registered function
|
2021-10-21 11:26:43 +02:00
|
|
|
#[inline]
|
2021-07-14 07:57:58 +02:00
|
|
|
pub fn call_fn_with_constant_arguments(
|
|
|
|
&self,
|
2022-01-04 08:22:48 +01:00
|
|
|
fn_name: &str,
|
2021-07-14 07:57:58 +02:00
|
|
|
arg_values: &mut [Dynamic],
|
|
|
|
) -> Option<Dynamic> {
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
let lib = self.lib;
|
|
|
|
#[cfg(feature = "no_function")]
|
|
|
|
let lib = &[];
|
|
|
|
|
2021-07-14 07:57:58 +02:00
|
|
|
self.engine
|
|
|
|
.call_native_fn(
|
2022-01-28 11:59:18 +01:00
|
|
|
&mut GlobalRuntimeState::new(&self.engine),
|
2021-11-07 11:12:37 +01:00
|
|
|
&mut EvalState::new(),
|
2021-11-29 02:43:35 +01:00
|
|
|
lib,
|
2022-01-04 08:22:48 +01:00
|
|
|
fn_name,
|
2021-11-27 16:04:45 +01:00
|
|
|
calc_fn_hash(&fn_name, arg_values.len()),
|
2021-07-14 07:57:58 +02:00
|
|
|
&mut arg_values.iter_mut().collect::<StaticVec<_>>(),
|
|
|
|
false,
|
|
|
|
false,
|
|
|
|
Position::NONE,
|
2022-02-02 07:47:35 +01:00
|
|
|
0,
|
2021-07-14 07:57:58 +02:00
|
|
|
)
|
|
|
|
.ok()
|
2022-02-08 02:02:15 +01:00
|
|
|
.map(|(v, ..)| v)
|
2021-07-14 07:57:58 +02:00
|
|
|
}
|
2020-04-09 12:45:49 +02:00
|
|
|
}
|
|
|
|
|
2021-12-27 15:28:11 +01:00
|
|
|
// Has a system function a Rust-native override?
|
2022-01-04 08:22:48 +01:00
|
|
|
fn has_native_fn_override(
|
|
|
|
engine: &Engine,
|
|
|
|
hash_script: u64,
|
|
|
|
arg_types: impl AsRef<[TypeId]>,
|
|
|
|
) -> bool {
|
|
|
|
let hash_params = calc_fn_params_hash(arg_types.as_ref().iter().cloned());
|
2021-12-27 15:28:11 +01:00
|
|
|
let hash = combine_hashes(hash_script, hash_params);
|
|
|
|
|
|
|
|
// First check the global namespace and packages, but skip modules that are standard because
|
|
|
|
// they should never conflict with system functions.
|
2022-01-29 04:09:43 +01:00
|
|
|
let result = engine
|
|
|
|
.global_modules
|
|
|
|
.iter()
|
|
|
|
.filter(|m| !m.standard)
|
|
|
|
.any(|m| m.contains_fn(hash));
|
|
|
|
|
|
|
|
#[cfg(not(feature = "no_module"))]
|
|
|
|
// Then check sub-modules
|
|
|
|
let result = result
|
|
|
|
|| engine
|
|
|
|
.global_sub_modules
|
|
|
|
.values()
|
|
|
|
.any(|m| m.contains_qualified_fn(hash));
|
|
|
|
|
|
|
|
result
|
2021-12-27 15:28:11 +01:00
|
|
|
}
|
|
|
|
|
2020-12-26 16:21:16 +01:00
|
|
|
/// Optimize a block of [statements][Stmt].
|
2020-11-12 05:37:42 +01:00
|
|
|
fn optimize_stmt_block(
|
2022-02-16 05:57:26 +01:00
|
|
|
mut statements: StmtBlockContainer,
|
2021-07-04 10:40:15 +02:00
|
|
|
state: &mut OptimizerState,
|
2020-11-12 05:37:42 +01:00
|
|
|
preserve_result: bool,
|
2021-03-13 16:43:05 +01:00
|
|
|
is_internal: bool,
|
|
|
|
reduce_return: bool,
|
2022-02-16 05:57:26 +01:00
|
|
|
) -> StmtBlockContainer {
|
2021-03-10 05:27:10 +01:00
|
|
|
if statements.is_empty() {
|
|
|
|
return statements;
|
|
|
|
}
|
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
let mut is_dirty = state.is_dirty();
|
2021-01-12 16:52:50 +01:00
|
|
|
|
2021-03-13 16:43:05 +01:00
|
|
|
let is_pure = if is_internal {
|
|
|
|
Stmt::is_internally_pure
|
|
|
|
} else {
|
|
|
|
Stmt::is_pure
|
|
|
|
};
|
|
|
|
|
2021-12-30 05:14:54 +01:00
|
|
|
// Flatten blocks
|
|
|
|
loop {
|
|
|
|
if let Some(n) = statements.iter().enumerate().find_map(|(i, s)| match s {
|
2022-02-08 02:02:15 +01:00
|
|
|
Stmt::Block(block, ..) if !block.iter().any(Stmt::is_block_dependent) => Some(i),
|
2021-12-30 05:14:54 +01:00
|
|
|
_ => None,
|
|
|
|
}) {
|
|
|
|
let (first, second) = statements.split_at_mut(n);
|
|
|
|
let stmt = mem::take(&mut second[0]);
|
|
|
|
let mut stmts = match stmt {
|
2022-02-08 02:02:15 +01:00
|
|
|
Stmt::Block(block, ..) => block,
|
2021-12-30 05:19:41 +01:00
|
|
|
stmt => unreachable!("Stmt::Block expected but gets {:?}", stmt),
|
2021-12-30 05:14:54 +01:00
|
|
|
};
|
|
|
|
statements = first
|
|
|
|
.iter_mut()
|
|
|
|
.map(mem::take)
|
|
|
|
.chain(stmts.iter_mut().map(mem::take))
|
|
|
|
.chain(second.iter_mut().skip(1).map(mem::take))
|
|
|
|
.collect();
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
is_dirty = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Optimize
|
2021-03-11 11:29:22 +01:00
|
|
|
loop {
|
|
|
|
state.clear_dirty();
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
let orig_constants_len = state.variables.len(); // Original number of constants in the state, for restore later
|
|
|
|
let orig_propagate_constants = state.propagate_constants;
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
// Remove everything following control flow breaking statements
|
|
|
|
let mut dead_code = false;
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
statements.retain(|stmt| {
|
|
|
|
if dead_code {
|
|
|
|
state.set_dirty();
|
|
|
|
false
|
|
|
|
} else if stmt.is_control_flow_break() {
|
|
|
|
dead_code = true;
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
});
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
// Optimize each statement in the block
|
2022-01-28 11:59:18 +01:00
|
|
|
for stmt in statements.iter_mut() {
|
2021-03-11 11:29:22 +01:00
|
|
|
match stmt {
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Var(x, options, ..) => {
|
2022-02-25 04:42:59 +01:00
|
|
|
if options.contains(ASTFlags::CONSTANT) {
|
2021-08-03 16:19:25 +02:00
|
|
|
// Add constant literals into the state
|
2022-02-16 10:51:14 +01:00
|
|
|
optimize_expr(&mut x.1, state, false);
|
2021-08-03 16:19:25 +02:00
|
|
|
|
2022-02-16 10:51:14 +01:00
|
|
|
if x.1.is_constant() {
|
2021-08-03 16:19:25 +02:00
|
|
|
state.push_var(
|
2022-02-16 10:51:14 +01:00
|
|
|
x.0.name.as_str(),
|
2021-08-03 16:19:25 +02:00
|
|
|
AccessMode::ReadOnly,
|
2022-02-16 10:51:14 +01:00
|
|
|
x.1.get_literal_value(),
|
2021-08-03 16:19:25 +02:00
|
|
|
);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Add variables into the state
|
2022-02-16 10:51:14 +01:00
|
|
|
optimize_expr(&mut x.1, state, false);
|
|
|
|
state.push_var(x.0.name.as_str(), AccessMode::ReadWrite, None);
|
2021-03-11 11:29:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Optimize the statement
|
|
|
|
_ => optimize_stmt(stmt, state, preserve_result),
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
2022-01-28 11:59:18 +01:00
|
|
|
}
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-13 16:43:05 +01:00
|
|
|
// Remove all pure statements except the last one
|
|
|
|
let mut index = 0;
|
|
|
|
let mut first_non_constant = statements
|
|
|
|
.iter()
|
|
|
|
.rev()
|
|
|
|
.enumerate()
|
|
|
|
.find_map(|(i, stmt)| match stmt {
|
|
|
|
stmt if !is_pure(stmt) => Some(i),
|
|
|
|
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Var(x, ..) if x.1.is_constant() => Some(i),
|
|
|
|
Stmt::Expr(e) if !e.is_constant() => Some(i),
|
2021-03-13 16:43:05 +01:00
|
|
|
|
2021-03-14 03:47:21 +01:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Import(x, ..) if !x.0.is_constant() => Some(i),
|
2021-03-14 03:47:21 +01:00
|
|
|
|
2021-04-24 07:42:45 +02:00
|
|
|
_ => None,
|
2021-03-13 16:43:05 +01:00
|
|
|
})
|
2021-04-24 07:42:45 +02:00
|
|
|
.map_or(0, |n| statements.len() - n - 1);
|
2021-03-13 16:43:05 +01:00
|
|
|
|
|
|
|
while index < statements.len() {
|
|
|
|
if preserve_result && index >= statements.len() - 1 {
|
|
|
|
break;
|
|
|
|
} else {
|
2021-06-14 06:02:22 +02:00
|
|
|
match statements[index] {
|
|
|
|
ref stmt if is_pure(stmt) && index >= first_non_constant => {
|
2021-03-13 16:43:05 +01:00
|
|
|
state.set_dirty();
|
|
|
|
statements.remove(index);
|
|
|
|
}
|
2021-06-14 06:02:22 +02:00
|
|
|
ref stmt if stmt.is_pure() => {
|
2021-03-13 16:43:05 +01:00
|
|
|
state.set_dirty();
|
|
|
|
if index < first_non_constant {
|
|
|
|
first_non_constant -= 1;
|
|
|
|
}
|
|
|
|
statements.remove(index);
|
|
|
|
}
|
|
|
|
_ => index += 1,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
// Remove all pure statements that do not return values at the end of a block.
|
|
|
|
// We cannot remove anything for non-pure statements due to potential side-effects.
|
|
|
|
if preserve_result {
|
|
|
|
loop {
|
2021-06-14 06:02:22 +02:00
|
|
|
match statements[..] {
|
2021-03-13 16:43:05 +01:00
|
|
|
// { return; } -> {}
|
2022-02-16 10:51:14 +01:00
|
|
|
[Stmt::Return(None, options, ..)]
|
2022-02-25 04:42:59 +01:00
|
|
|
if reduce_return && !options.contains(ASTFlags::BREAK) =>
|
2021-09-10 14:23:59 +02:00
|
|
|
{
|
2021-03-13 16:43:05 +01:00
|
|
|
state.set_dirty();
|
|
|
|
statements.clear();
|
|
|
|
}
|
2021-06-14 06:02:22 +02:00
|
|
|
[ref stmt] if !stmt.returns_value() && is_pure(stmt) => {
|
2021-03-11 11:29:22 +01:00
|
|
|
state.set_dirty();
|
|
|
|
statements.clear();
|
|
|
|
}
|
2021-03-13 16:43:05 +01:00
|
|
|
// { ...; return; } -> { ... }
|
2022-02-16 10:51:14 +01:00
|
|
|
[.., ref last_stmt, Stmt::Return(None, options, ..)]
|
2021-09-10 14:23:59 +02:00
|
|
|
if reduce_return
|
2022-02-25 04:42:59 +01:00
|
|
|
&& !options.contains(ASTFlags::BREAK)
|
2021-09-10 14:23:59 +02:00
|
|
|
&& !last_stmt.returns_value() =>
|
2021-03-13 16:43:05 +01:00
|
|
|
{
|
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
statements.pop().unwrap();
|
2021-03-13 16:43:05 +01:00
|
|
|
}
|
|
|
|
// { ...; return val; } -> { ...; val }
|
2022-02-16 10:51:14 +01:00
|
|
|
[.., Stmt::Return(ref mut expr, options, pos)]
|
2022-02-25 04:42:59 +01:00
|
|
|
if reduce_return && !options.contains(ASTFlags::BREAK) =>
|
2021-03-13 16:43:05 +01:00
|
|
|
{
|
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
*statements.last_mut().unwrap() = expr
|
2021-12-12 05:33:22 +01:00
|
|
|
.as_mut()
|
|
|
|
.map_or_else(|| Stmt::Noop(pos), |e| Stmt::Expr(mem::take(e)));
|
2021-03-13 16:43:05 +01:00
|
|
|
}
|
2021-07-01 06:27:29 +02:00
|
|
|
// { ...; stmt; noop } -> done
|
2022-02-08 02:46:14 +01:00
|
|
|
[.., ref second_last_stmt, Stmt::Noop(..)]
|
2021-07-01 06:27:29 +02:00
|
|
|
if second_last_stmt.returns_value() =>
|
|
|
|
{
|
|
|
|
break
|
|
|
|
}
|
|
|
|
// { ...; stmt_that_returns; pure_non_value_stmt } -> { ...; stmt_that_returns; noop }
|
|
|
|
// { ...; stmt; pure_non_value_stmt } -> { ...; stmt }
|
2021-06-14 06:02:22 +02:00
|
|
|
[.., ref second_last_stmt, ref last_stmt]
|
2021-03-13 16:43:05 +01:00
|
|
|
if !last_stmt.returns_value() && is_pure(last_stmt) =>
|
2021-03-11 11:29:22 +01:00
|
|
|
{
|
|
|
|
state.set_dirty();
|
|
|
|
if second_last_stmt.returns_value() {
|
2022-01-06 04:07:52 +01:00
|
|
|
*statements.last_mut().unwrap() = Stmt::Noop(last_stmt.position());
|
2021-03-11 11:29:22 +01:00
|
|
|
} else {
|
2022-01-06 04:07:52 +01:00
|
|
|
statements.pop().unwrap();
|
2021-03-11 11:29:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => break,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
loop {
|
2021-06-14 06:02:22 +02:00
|
|
|
match statements[..] {
|
|
|
|
[ref stmt] if is_pure(stmt) => {
|
2021-03-11 11:29:22 +01:00
|
|
|
state.set_dirty();
|
|
|
|
statements.clear();
|
|
|
|
}
|
2021-03-13 16:43:05 +01:00
|
|
|
// { ...; return; } -> { ... }
|
2022-02-16 10:51:14 +01:00
|
|
|
[.., Stmt::Return(None, options, ..)]
|
2022-02-25 04:42:59 +01:00
|
|
|
if reduce_return && !options.contains(ASTFlags::BREAK) =>
|
2021-03-13 16:43:05 +01:00
|
|
|
{
|
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
statements.pop().unwrap();
|
2021-03-13 16:43:05 +01:00
|
|
|
}
|
|
|
|
// { ...; return pure_val; } -> { ... }
|
2022-02-16 10:51:14 +01:00
|
|
|
[.., Stmt::Return(Some(ref expr), options, ..)]
|
2021-09-10 14:23:59 +02:00
|
|
|
if reduce_return
|
2022-02-25 04:42:59 +01:00
|
|
|
&& !options.contains(ASTFlags::BREAK)
|
2021-09-10 14:23:59 +02:00
|
|
|
&& expr.is_pure() =>
|
2021-03-13 16:43:05 +01:00
|
|
|
{
|
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
statements.pop().unwrap();
|
2021-03-13 16:43:05 +01:00
|
|
|
}
|
2021-06-14 06:02:22 +02:00
|
|
|
[.., ref last_stmt] if is_pure(last_stmt) => {
|
2021-03-11 11:29:22 +01:00
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
statements.pop().unwrap();
|
2021-03-11 11:29:22 +01:00
|
|
|
}
|
|
|
|
_ => break,
|
|
|
|
}
|
|
|
|
}
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
// Pop the stack and remove all the local constants
|
|
|
|
state.restore_var(orig_constants_len);
|
|
|
|
state.propagate_constants = orig_propagate_constants;
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
if !state.is_dirty() {
|
|
|
|
break;
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
is_dirty = true;
|
|
|
|
}
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
if is_dirty {
|
2020-11-12 05:37:42 +01:00
|
|
|
state.set_dirty();
|
|
|
|
}
|
|
|
|
|
2021-03-13 16:43:05 +01:00
|
|
|
statements.shrink_to_fit();
|
2021-03-10 05:27:10 +01:00
|
|
|
statements
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
|
|
|
|
2020-12-26 16:21:16 +01:00
|
|
|
/// Optimize a [statement][Stmt].
|
2021-07-04 10:40:15 +02:00
|
|
|
fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: bool) {
|
2020-03-09 14:57:07 +01:00
|
|
|
match stmt {
|
2021-04-23 17:37:10 +02:00
|
|
|
// var = var op expr => var op= expr
|
2022-02-08 02:02:15 +01:00
|
|
|
Stmt::Assignment(x, ..)
|
2022-01-28 03:11:40 +01:00
|
|
|
if x.0.is_none()
|
|
|
|
&& x.1.lhs.is_variable_access(true)
|
2022-02-08 02:02:15 +01:00
|
|
|
&& matches!(&x.1.rhs, Expr::FnCall(x2, ..)
|
2021-04-24 05:55:40 +02:00
|
|
|
if Token::lookup_from_syntax(&x2.name).map(|t| t.has_op_assignment()).unwrap_or(false)
|
2021-06-08 08:46:49 +02:00
|
|
|
&& x2.args.len() == 2
|
2022-01-28 03:11:40 +01:00
|
|
|
&& x2.args[0].get_variable_name(true) == x.1.lhs.get_variable_name(true)
|
2021-04-23 17:37:10 +02:00
|
|
|
) =>
|
|
|
|
{
|
2022-01-28 03:11:40 +01:00
|
|
|
match x.1.rhs {
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::FnCall(ref mut x2, ..) => {
|
2021-04-23 17:37:10 +02:00
|
|
|
state.set_dirty();
|
2022-01-28 03:11:40 +01:00
|
|
|
x.0 = Some(OpAssignment::new_from_base(&x2.name));
|
2021-06-08 08:46:49 +02:00
|
|
|
|
|
|
|
let value = mem::take(&mut x2.args[1]);
|
|
|
|
|
|
|
|
if let Expr::Stack(slot, pos) = value {
|
2022-01-28 03:11:40 +01:00
|
|
|
x.1.rhs =
|
2022-01-06 04:07:52 +01:00
|
|
|
Expr::from_dynamic(mem::take(x2.constants.get_mut(slot).unwrap()), pos);
|
2021-04-23 17:37:10 +02:00
|
|
|
} else {
|
2022-01-28 03:11:40 +01:00
|
|
|
x.1.rhs = value;
|
2021-06-08 08:46:49 +02:00
|
|
|
}
|
2021-04-23 17:37:10 +02:00
|
|
|
}
|
2021-12-30 05:14:54 +01:00
|
|
|
ref expr => unreachable!("Expr::FnCall expected but gets {:?}", expr),
|
2021-04-23 17:37:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 06:08:19 +01:00
|
|
|
// expr op= expr
|
2022-02-08 02:02:15 +01:00
|
|
|
Stmt::Assignment(x, ..) => {
|
2022-01-28 03:11:40 +01:00
|
|
|
if !x.1.lhs.is_variable_access(false) {
|
|
|
|
optimize_expr(&mut x.1.lhs, state, false);
|
2020-11-03 06:08:19 +01:00
|
|
|
}
|
2022-01-28 03:11:40 +01:00
|
|
|
optimize_expr(&mut x.1.rhs, state, false);
|
|
|
|
}
|
2020-11-14 16:43:36 +01:00
|
|
|
|
2021-03-10 05:27:10 +01:00
|
|
|
// if expr {}
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::If(x, ..) if x.1.is_empty() && x.2.is_empty() => {
|
|
|
|
let condition = &mut x.0;
|
2020-03-13 11:12:41 +01:00
|
|
|
state.set_dirty();
|
2020-03-12 16:46:52 +01:00
|
|
|
|
2022-02-04 05:04:33 +01:00
|
|
|
let pos = condition.start_position();
|
2020-11-12 05:37:42 +01:00
|
|
|
let mut expr = mem::take(condition);
|
2021-06-02 08:29:18 +02:00
|
|
|
optimize_expr(&mut expr, state, false);
|
2020-03-12 16:46:52 +01:00
|
|
|
|
2020-11-12 05:37:42 +01:00
|
|
|
*stmt = if preserve_result {
|
2020-03-18 03:36:50 +01:00
|
|
|
// -> { expr, Noop }
|
2022-02-16 10:51:14 +01:00
|
|
|
(
|
|
|
|
[Stmt::Expr(expr.into()), Stmt::Noop(pos)],
|
|
|
|
pos,
|
|
|
|
Position::NONE,
|
2022-02-04 05:04:33 +01:00
|
|
|
)
|
2022-02-16 10:51:14 +01:00
|
|
|
.into()
|
2020-03-14 16:41:15 +01:00
|
|
|
} else {
|
2020-03-18 03:36:50 +01:00
|
|
|
// -> expr
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Expr(expr.into())
|
2020-11-12 05:37:42 +01:00
|
|
|
};
|
2020-03-12 16:46:52 +01:00
|
|
|
}
|
2021-03-10 05:27:10 +01:00
|
|
|
// if false { if_block } -> Noop
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::If(x, ..) if matches!(x.0, Expr::BoolConstant(false, ..)) && x.2.is_empty() => {
|
|
|
|
if let Expr::BoolConstant(false, pos) = x.0 {
|
|
|
|
state.set_dirty();
|
|
|
|
*stmt = Stmt::Noop(pos);
|
|
|
|
} else {
|
|
|
|
unreachable!("`Expr::BoolConstant`");
|
|
|
|
}
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
2020-10-27 11:18:19 +01:00
|
|
|
// if false { if_block } else { else_block } -> else_block
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::If(x, ..) if matches!(x.0, Expr::BoolConstant(false, ..)) => {
|
2021-03-10 05:27:10 +01:00
|
|
|
state.set_dirty();
|
2021-12-15 16:21:05 +01:00
|
|
|
*stmt =
|
2022-02-16 10:51:14 +01:00
|
|
|
match optimize_stmt_block(mem::take(&mut *x.2), state, preserve_result, true, false)
|
2021-12-15 16:21:05 +01:00
|
|
|
{
|
2022-02-16 10:51:14 +01:00
|
|
|
statements if statements.is_empty() => Stmt::Noop(x.2.position()),
|
|
|
|
statements => (statements, x.2.span()).into(),
|
2021-12-15 16:21:05 +01:00
|
|
|
}
|
2020-10-27 11:18:19 +01:00
|
|
|
}
|
|
|
|
// if true { if_block } else { else_block } -> if_block
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::If(x, ..) if matches!(x.0, Expr::BoolConstant(true, ..)) => {
|
2021-03-10 05:27:10 +01:00
|
|
|
state.set_dirty();
|
2021-12-15 16:21:05 +01:00
|
|
|
*stmt =
|
2022-02-16 10:51:14 +01:00
|
|
|
match optimize_stmt_block(mem::take(&mut *x.1), state, preserve_result, true, false)
|
2021-12-15 16:21:05 +01:00
|
|
|
{
|
2022-02-16 10:51:14 +01:00
|
|
|
statements if statements.is_empty() => Stmt::Noop(x.1.position()),
|
|
|
|
statements => (statements, x.1.span()).into(),
|
2021-12-15 16:21:05 +01:00
|
|
|
}
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// if expr { if_block } else { else_block }
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::If(x, ..) => {
|
|
|
|
let (condition, body, other) = x.as_mut();
|
2021-06-02 08:29:18 +02:00
|
|
|
optimize_expr(condition, state, false);
|
2022-02-16 10:51:14 +01:00
|
|
|
**body =
|
|
|
|
optimize_stmt_block(mem::take(&mut **body), state, preserve_result, true, false);
|
|
|
|
**other =
|
|
|
|
optimize_stmt_block(mem::take(&mut **other), state, preserve_result, true, false);
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
2020-10-27 11:18:19 +01:00
|
|
|
|
2020-11-14 16:43:36 +01:00
|
|
|
// switch const { ... }
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Switch(x, pos) if x.0.is_constant() => {
|
|
|
|
let (
|
|
|
|
match_expr,
|
|
|
|
SwitchCases {
|
|
|
|
cases,
|
|
|
|
ranges,
|
|
|
|
def_case,
|
|
|
|
},
|
|
|
|
) = x.as_mut();
|
|
|
|
|
2022-01-06 04:07:52 +01:00
|
|
|
let value = match_expr.get_literal_value().unwrap();
|
2020-11-14 16:43:36 +01:00
|
|
|
let hasher = &mut get_hasher();
|
|
|
|
value.hash(hasher);
|
|
|
|
let hash = hasher.finish();
|
|
|
|
|
2021-12-15 05:06:17 +01:00
|
|
|
// First check hashes
|
2022-01-28 03:11:40 +01:00
|
|
|
if let Some(block) = cases.get_mut(&hash) {
|
|
|
|
if let Some(mut condition) = mem::take(&mut block.condition) {
|
2021-04-16 06:04:33 +02:00
|
|
|
// switch const { case if condition => stmt, _ => def } => if condition { stmt } else { def }
|
2021-06-02 08:29:18 +02:00
|
|
|
optimize_expr(&mut condition, state, false);
|
2021-04-16 06:04:33 +02:00
|
|
|
|
2021-12-15 05:06:17 +01:00
|
|
|
let def_stmt =
|
2022-02-16 10:51:14 +01:00
|
|
|
optimize_stmt_block(mem::take(def_case), state, true, true, false);
|
2021-04-16 06:04:33 +02:00
|
|
|
|
|
|
|
*stmt = Stmt::If(
|
2022-02-16 10:51:14 +01:00
|
|
|
(
|
|
|
|
condition,
|
2022-01-28 03:11:40 +01:00
|
|
|
mem::take(&mut block.statements),
|
2022-02-16 10:51:14 +01:00
|
|
|
StmtBlock::new_with_span(
|
|
|
|
def_stmt,
|
|
|
|
def_case.span_or_else(*pos, Position::NONE),
|
|
|
|
),
|
|
|
|
)
|
2022-01-28 03:11:40 +01:00
|
|
|
.into(),
|
2022-02-04 05:04:33 +01:00
|
|
|
match_expr.start_position(),
|
2021-04-16 06:04:33 +02:00
|
|
|
);
|
|
|
|
} else {
|
|
|
|
// Promote the matched case
|
2022-01-28 03:11:40 +01:00
|
|
|
let statements = optimize_stmt_block(
|
|
|
|
mem::take(&mut block.statements),
|
|
|
|
state,
|
|
|
|
true,
|
|
|
|
true,
|
|
|
|
false,
|
|
|
|
);
|
2022-02-16 10:51:14 +01:00
|
|
|
*stmt = (statements, block.statements.span()).into();
|
2021-04-16 06:04:33 +02:00
|
|
|
}
|
2021-12-15 05:06:17 +01:00
|
|
|
|
|
|
|
state.set_dirty();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Then check ranges
|
|
|
|
if value.is::<INT>() && !ranges.is_empty() {
|
|
|
|
let value = value.as_int().expect("`INT`");
|
|
|
|
|
|
|
|
// Only one range or all ranges without conditions
|
2022-02-08 02:02:15 +01:00
|
|
|
if ranges.len() == 1 || ranges.iter().all(|(.., c)| !c.has_condition()) {
|
|
|
|
for (.., block) in
|
2021-12-15 05:06:17 +01:00
|
|
|
ranges
|
|
|
|
.iter_mut()
|
2022-02-08 02:02:15 +01:00
|
|
|
.filter(|&&mut (start, end, inclusive, ..)| {
|
2021-12-15 05:06:17 +01:00
|
|
|
(!inclusive && (start..end).contains(&value))
|
|
|
|
|| (inclusive && (start..=end).contains(&value))
|
|
|
|
})
|
|
|
|
{
|
2022-01-28 03:11:40 +01:00
|
|
|
if let Some(mut condition) = mem::take(&mut block.condition) {
|
2021-12-15 05:06:17 +01:00
|
|
|
// switch const { range if condition => stmt, _ => def } => if condition { stmt } else { def }
|
|
|
|
optimize_expr(&mut condition, state, false);
|
|
|
|
|
2022-02-16 10:51:14 +01:00
|
|
|
let def_stmt =
|
|
|
|
optimize_stmt_block(mem::take(def_case), state, true, true, false);
|
2021-12-15 05:06:17 +01:00
|
|
|
*stmt = Stmt::If(
|
2022-02-16 10:51:14 +01:00
|
|
|
(
|
|
|
|
condition,
|
2022-01-28 03:11:40 +01:00
|
|
|
mem::take(&mut block.statements),
|
2022-02-16 10:51:14 +01:00
|
|
|
StmtBlock::new_with_span(
|
|
|
|
def_stmt,
|
|
|
|
def_case.span_or_else(*pos, Position::NONE),
|
|
|
|
),
|
|
|
|
)
|
2021-12-15 15:12:51 +01:00
|
|
|
.into(),
|
2022-02-04 05:04:33 +01:00
|
|
|
match_expr.start_position(),
|
2021-12-15 05:06:17 +01:00
|
|
|
);
|
|
|
|
} else {
|
|
|
|
// Promote the matched case
|
2022-01-28 03:11:40 +01:00
|
|
|
let statements = mem::take(&mut *block.statements);
|
2021-12-15 05:06:17 +01:00
|
|
|
let statements =
|
|
|
|
optimize_stmt_block(statements, state, true, true, false);
|
2022-02-16 10:51:14 +01:00
|
|
|
*stmt = (statements, block.statements.span()).into();
|
2021-12-15 05:06:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
state.set_dirty();
|
|
|
|
return;
|
|
|
|
}
|
2021-04-16 07:15:11 +02:00
|
|
|
} else {
|
2021-12-15 05:06:17 +01:00
|
|
|
// Multiple ranges - clear the table and just keep the right ranges
|
2022-01-28 03:11:40 +01:00
|
|
|
if !cases.is_empty() {
|
2021-12-15 05:06:17 +01:00
|
|
|
state.set_dirty();
|
2022-01-28 03:11:40 +01:00
|
|
|
cases.clear();
|
2021-12-15 05:06:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
let old_ranges_len = ranges.len();
|
|
|
|
|
2022-02-08 02:02:15 +01:00
|
|
|
ranges.retain(|&mut (start, end, inclusive, ..)| {
|
2021-12-15 05:06:17 +01:00
|
|
|
(!inclusive && (start..end).contains(&value))
|
|
|
|
|| (inclusive && (start..=end).contains(&value))
|
|
|
|
});
|
|
|
|
|
|
|
|
if ranges.len() != old_ranges_len {
|
|
|
|
state.set_dirty();
|
|
|
|
}
|
|
|
|
|
2022-02-08 02:02:15 +01:00
|
|
|
for (.., block) in ranges.iter_mut() {
|
2022-01-28 03:11:40 +01:00
|
|
|
let statements = mem::take(&mut *block.statements);
|
|
|
|
*block.statements =
|
2021-12-15 05:06:17 +01:00
|
|
|
optimize_stmt_block(statements, state, preserve_result, true, false);
|
|
|
|
|
2022-01-28 03:11:40 +01:00
|
|
|
if let Some(mut condition) = mem::take(&mut block.condition) {
|
|
|
|
optimize_expr(&mut condition, state, false);
|
|
|
|
match condition {
|
2022-02-08 02:46:14 +01:00
|
|
|
Expr::Unit(..) | Expr::BoolConstant(true, ..) => state.set_dirty(),
|
2022-01-28 03:11:40 +01:00
|
|
|
_ => block.condition = Some(condition),
|
2021-12-15 05:06:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2021-04-16 06:04:33 +02:00
|
|
|
}
|
2021-12-15 05:06:17 +01:00
|
|
|
|
|
|
|
// Promote the default case
|
|
|
|
state.set_dirty();
|
2022-02-16 10:51:14 +01:00
|
|
|
let def_stmt = optimize_stmt_block(mem::take(def_case), state, true, true, false);
|
|
|
|
*stmt = (def_stmt, def_case.span_or_else(*pos, Position::NONE)).into();
|
2020-11-14 16:43:36 +01:00
|
|
|
}
|
|
|
|
// switch
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Switch(x, ..) => {
|
|
|
|
let (
|
|
|
|
match_expr,
|
|
|
|
SwitchCases {
|
|
|
|
cases,
|
|
|
|
ranges,
|
|
|
|
def_case,
|
|
|
|
..
|
|
|
|
},
|
|
|
|
) = x.as_mut();
|
|
|
|
|
2021-06-02 08:29:18 +02:00
|
|
|
optimize_expr(match_expr, state, false);
|
2022-02-16 10:51:14 +01:00
|
|
|
|
|
|
|
// Optimize cases
|
|
|
|
for block in cases.values_mut() {
|
2022-01-28 03:11:40 +01:00
|
|
|
let statements = mem::take(&mut *block.statements);
|
|
|
|
*block.statements =
|
|
|
|
optimize_stmt_block(statements, state, preserve_result, true, false);
|
2021-12-15 05:06:17 +01:00
|
|
|
|
2022-01-28 03:11:40 +01:00
|
|
|
if let Some(mut condition) = mem::take(&mut block.condition) {
|
2021-12-15 05:06:17 +01:00
|
|
|
optimize_expr(&mut condition, state, false);
|
|
|
|
match condition {
|
2022-02-08 02:46:14 +01:00
|
|
|
Expr::Unit(..) | Expr::BoolConstant(true, ..) => state.set_dirty(),
|
2022-01-28 03:11:40 +01:00
|
|
|
_ => block.condition = Some(condition),
|
2021-04-16 06:04:33 +02:00
|
|
|
}
|
|
|
|
}
|
2022-01-28 11:59:18 +01:00
|
|
|
}
|
2021-04-16 06:04:33 +02:00
|
|
|
|
|
|
|
// Remove false cases
|
2022-02-16 10:51:14 +01:00
|
|
|
cases.retain(|_, block| match block.condition {
|
|
|
|
Some(Expr::BoolConstant(false, ..)) => {
|
|
|
|
state.set_dirty();
|
|
|
|
false
|
|
|
|
}
|
|
|
|
_ => true,
|
|
|
|
});
|
|
|
|
|
|
|
|
// Optimize ranges
|
|
|
|
for (.., block) in ranges.iter_mut() {
|
|
|
|
let statements = mem::take(&mut *block.statements);
|
|
|
|
*block.statements =
|
|
|
|
optimize_stmt_block(statements, state, preserve_result, true, false);
|
|
|
|
|
|
|
|
if let Some(mut condition) = mem::take(&mut block.condition) {
|
|
|
|
optimize_expr(&mut condition, state, false);
|
|
|
|
match condition {
|
|
|
|
Expr::Unit(..) | Expr::BoolConstant(true, ..) => state.set_dirty(),
|
|
|
|
_ => block.condition = Some(condition),
|
|
|
|
}
|
|
|
|
}
|
2021-04-16 06:04:33 +02:00
|
|
|
}
|
|
|
|
|
2022-02-16 10:51:14 +01:00
|
|
|
// Remove false ranges
|
|
|
|
ranges.retain(|(.., block)| match block.condition {
|
|
|
|
Some(Expr::BoolConstant(false, ..)) => {
|
|
|
|
state.set_dirty();
|
|
|
|
false
|
|
|
|
}
|
|
|
|
_ => true,
|
|
|
|
});
|
|
|
|
|
|
|
|
let def_block = mem::take(&mut ***def_case);
|
|
|
|
***def_case = optimize_stmt_block(def_block, state, preserve_result, true, false);
|
2020-11-14 16:43:36 +01:00
|
|
|
}
|
|
|
|
|
2020-10-27 11:18:19 +01:00
|
|
|
// while false { block } -> Noop
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::While(x, ..) if matches!(x.0, Expr::BoolConstant(false, ..)) => match x.0 {
|
|
|
|
Expr::BoolConstant(false, pos) => {
|
|
|
|
state.set_dirty();
|
|
|
|
*stmt = Stmt::Noop(pos)
|
|
|
|
}
|
|
|
|
_ => unreachable!("`Expr::BoolConstant"),
|
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// while expr { block }
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::While(x, ..) => {
|
|
|
|
let (condition, body) = x.as_mut();
|
2021-06-02 08:29:18 +02:00
|
|
|
optimize_expr(condition, state, false);
|
2021-08-04 11:40:26 +02:00
|
|
|
if let Expr::BoolConstant(true, pos) = condition {
|
|
|
|
*condition = Expr::Unit(*pos);
|
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
**body = optimize_stmt_block(mem::take(&mut **body), state, false, true, false);
|
2021-03-10 05:27:10 +01:00
|
|
|
|
2021-03-13 16:43:05 +01:00
|
|
|
if body.len() == 1 {
|
2021-04-16 07:15:11 +02:00
|
|
|
match body[0] {
|
2021-03-10 05:27:10 +01:00
|
|
|
// while expr { break; } -> { expr; }
|
2022-02-25 04:42:59 +01:00
|
|
|
Stmt::BreakLoop(options, pos) if options.contains(ASTFlags::BREAK) => {
|
2021-03-10 05:27:10 +01:00
|
|
|
// Only a single break statement - turn into running the guard expression once
|
|
|
|
state.set_dirty();
|
|
|
|
if !condition.is_unit() {
|
2022-02-16 10:51:14 +01:00
|
|
|
let mut statements = vec![Stmt::Expr(mem::take(condition).into())];
|
2021-03-10 05:27:10 +01:00
|
|
|
if preserve_result {
|
|
|
|
statements.push(Stmt::Noop(pos))
|
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
*stmt = (statements, Span::new(pos, Position::NONE)).into();
|
2021-03-10 05:27:10 +01:00
|
|
|
} else {
|
|
|
|
*stmt = Stmt::Noop(pos);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
_ => (),
|
2020-03-17 10:33:37 +01:00
|
|
|
}
|
2020-10-27 11:18:19 +01:00
|
|
|
}
|
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
// do { block } until true -> { block }
|
|
|
|
Stmt::Do(x, options, ..)
|
|
|
|
if matches!(x.0, Expr::BoolConstant(true, ..))
|
2022-02-25 04:42:59 +01:00
|
|
|
&& options.contains(ASTFlags::NEGATED) =>
|
2021-08-03 16:19:25 +02:00
|
|
|
{
|
2020-11-20 15:23:37 +01:00
|
|
|
state.set_dirty();
|
2022-02-16 10:51:14 +01:00
|
|
|
*stmt = (
|
|
|
|
optimize_stmt_block(mem::take(&mut *x.1), state, false, true, false),
|
|
|
|
x.1.span(),
|
|
|
|
)
|
|
|
|
.into();
|
|
|
|
}
|
|
|
|
// do { block } while false -> { block }
|
|
|
|
Stmt::Do(x, options, ..)
|
|
|
|
if matches!(x.0, Expr::BoolConstant(false, ..))
|
2022-02-25 04:42:59 +01:00
|
|
|
&& !options.contains(ASTFlags::NEGATED) =>
|
2022-02-16 10:51:14 +01:00
|
|
|
{
|
|
|
|
state.set_dirty();
|
|
|
|
*stmt = (
|
|
|
|
optimize_stmt_block(mem::take(&mut *x.1), state, false, true, false),
|
|
|
|
x.1.span(),
|
|
|
|
)
|
|
|
|
.into();
|
2020-11-20 15:23:37 +01:00
|
|
|
}
|
|
|
|
// do { block } while|until expr
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Do(x, ..) => {
|
|
|
|
optimize_expr(&mut x.0, state, false);
|
|
|
|
*x.1 = optimize_stmt_block(mem::take(&mut *x.1), state, false, true, false);
|
2020-11-12 05:37:42 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// for id in expr { block }
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::For(x, ..) => {
|
2022-02-18 08:04:46 +01:00
|
|
|
optimize_expr(&mut x.2, state, false);
|
2022-02-16 10:51:14 +01:00
|
|
|
*x.3 = optimize_stmt_block(mem::take(&mut *x.3), state, false, true, false);
|
2020-10-27 12:23:43 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// let id = expr;
|
2022-02-25 04:42:59 +01:00
|
|
|
Stmt::Var(x, options, ..) if !options.contains(ASTFlags::CONSTANT) => {
|
2022-02-16 10:51:14 +01:00
|
|
|
optimize_expr(&mut x.1, state, false)
|
2021-08-03 16:19:25 +02:00
|
|
|
}
|
2020-10-20 17:16:03 +02:00
|
|
|
// import expr as var;
|
2020-07-26 09:53:22 +02:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Import(x, ..) => optimize_expr(&mut x.0, state, false),
|
2020-03-18 03:36:50 +01:00
|
|
|
// { block }
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Block(block) => {
|
|
|
|
let span = block.span();
|
|
|
|
let statements = block.take_statements().into_vec().into();
|
2021-05-05 12:38:52 +02:00
|
|
|
let mut block = optimize_stmt_block(statements, state, preserve_result, true, false);
|
2021-04-05 08:57:07 +02:00
|
|
|
|
|
|
|
match block.as_mut_slice() {
|
|
|
|
[] => {
|
2021-03-10 05:27:10 +01:00
|
|
|
state.set_dirty();
|
2022-02-08 16:01:47 +01:00
|
|
|
*stmt = Stmt::Noop(span.start());
|
2021-03-10 05:27:10 +01:00
|
|
|
}
|
2021-12-30 05:14:54 +01:00
|
|
|
// Only one statement which is not block-dependent - promote
|
|
|
|
[s] if !s.is_block_dependent() => {
|
2021-03-10 05:27:10 +01:00
|
|
|
state.set_dirty();
|
2021-04-05 08:57:07 +02:00
|
|
|
*stmt = mem::take(s);
|
2021-03-10 05:27:10 +01:00
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
_ => *stmt = (block, span).into(),
|
2021-04-05 08:57:07 +02:00
|
|
|
}
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
2021-03-13 16:43:05 +01:00
|
|
|
// try { pure try_block } catch ( var ) { catch_block } -> try_block
|
2022-02-08 02:02:15 +01:00
|
|
|
Stmt::TryCatch(x, ..) if x.try_block.iter().all(Stmt::is_pure) => {
|
2020-10-20 17:16:03 +02:00
|
|
|
// If try block is pure, there will never be any exceptions
|
|
|
|
state.set_dirty();
|
2022-02-16 10:51:14 +01:00
|
|
|
*stmt = (
|
|
|
|
optimize_stmt_block(mem::take(&mut *x.try_block), state, false, true, false),
|
2022-02-08 16:01:47 +01:00
|
|
|
x.try_block.span(),
|
2022-02-16 10:51:14 +01:00
|
|
|
)
|
|
|
|
.into();
|
2020-10-20 17:16:03 +02:00
|
|
|
}
|
2021-03-13 16:43:05 +01:00
|
|
|
// try { try_block } catch ( var ) { catch_block }
|
2022-02-08 02:02:15 +01:00
|
|
|
Stmt::TryCatch(x, ..) => {
|
2022-01-28 03:11:40 +01:00
|
|
|
*x.try_block =
|
|
|
|
optimize_stmt_block(mem::take(&mut *x.try_block), state, false, true, false);
|
|
|
|
*x.catch_block =
|
|
|
|
optimize_stmt_block(mem::take(&mut *x.catch_block), state, false, true, false);
|
2020-10-27 11:18:19 +01:00
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
|
|
|
|
Stmt::Expr(expr) => {
|
2021-06-02 08:29:18 +02:00
|
|
|
optimize_expr(expr, state, false);
|
2022-02-16 10:51:14 +01:00
|
|
|
|
|
|
|
match expr.as_mut() {
|
|
|
|
// func(...)
|
2021-04-21 12:16:24 +02:00
|
|
|
Expr::FnCall(x, pos) => {
|
|
|
|
state.set_dirty();
|
|
|
|
*stmt = Stmt::FnCall(mem::take(x), *pos);
|
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
// {...};
|
|
|
|
Expr::Stmt(x) => {
|
|
|
|
if x.is_empty() {
|
|
|
|
state.set_dirty();
|
|
|
|
*stmt = Stmt::Noop(x.position());
|
|
|
|
} else {
|
|
|
|
state.set_dirty();
|
|
|
|
*stmt = mem::take(&mut **x).into();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// expr;
|
2021-04-21 12:16:24 +02:00
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
}
|
2022-02-16 10:51:14 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// return expr;
|
2022-02-16 10:51:14 +01:00
|
|
|
Stmt::Return(Some(ref mut expr), ..) => optimize_expr(expr, state, false),
|
2020-11-12 05:37:42 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// All other statements - skip
|
2020-11-12 05:37:42 +01:00
|
|
|
_ => (),
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-26 16:21:16 +01:00
|
|
|
/// Optimize an [expression][Expr].
|
2021-08-13 07:42:39 +02:00
|
|
|
fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, chaining: bool) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// These keywords are handled specially
|
2020-10-05 06:14:34 +02:00
|
|
|
const DONT_EVAL_KEYWORDS: &[&str] = &[
|
2020-11-22 08:41:55 +01:00
|
|
|
KEYWORD_PRINT, // side effects
|
|
|
|
KEYWORD_DEBUG, // side effects
|
|
|
|
KEYWORD_EVAL, // arbitrary scripts
|
2020-10-05 06:14:34 +02:00
|
|
|
];
|
2020-03-17 03:27:43 +01:00
|
|
|
|
2021-08-13 07:42:39 +02:00
|
|
|
let _chaining = chaining;
|
|
|
|
|
2020-03-09 14:57:07 +01:00
|
|
|
match expr {
|
2020-11-04 04:49:02 +01:00
|
|
|
// {}
|
2021-04-16 07:15:11 +02:00
|
|
|
Expr::Stmt(x) if x.is_empty() => { state.set_dirty(); *expr = Expr::Unit(x.position()) }
|
2021-04-05 08:57:07 +02:00
|
|
|
// { stmt; ... } - do not count promotion as dirty because it gets turned back into an array
|
|
|
|
Expr::Stmt(x) => {
|
2021-12-15 16:21:05 +01:00
|
|
|
***x = optimize_stmt_block(mem::take(&mut **x), state, true, true, false);
|
2021-04-05 08:57:07 +02:00
|
|
|
|
|
|
|
// { Stmt(Expr) } - promote
|
2021-04-16 07:15:11 +02:00
|
|
|
match x.as_mut().as_mut() {
|
2021-04-05 08:57:07 +02:00
|
|
|
[ Stmt::Expr(e) ] => { state.set_dirty(); *expr = mem::take(e); }
|
|
|
|
_ => ()
|
2021-04-04 07:13:07 +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"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Dot(x,_, ..) if !_chaining => match (&mut x.lhs, &mut x.rhs) {
|
2020-04-10 15:02:13 +02:00
|
|
|
// map.string
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::Map(m, pos), Expr::Property(p, ..)) if m.0.iter().all(|(.., x)| x.is_pure()) => {
|
2022-01-28 03:11:40 +01:00
|
|
|
let prop = p.2.as_str();
|
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();
|
2022-02-08 02:02:15 +01:00
|
|
|
*expr = mem::take(&mut m.0).into_iter().find(|(x, ..)| x.name == prop)
|
|
|
|
.map(|(.., mut expr)| { expr.set_position(*pos); expr })
|
2020-11-12 05:37:42 +01:00
|
|
|
.unwrap_or_else(|| Expr::Unit(*pos));
|
2020-04-10 15:02:13 +02:00
|
|
|
}
|
2020-11-03 06:08:19 +01:00
|
|
|
// var.rhs
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::Variable(..), rhs) => optimize_expr(rhs, state, true),
|
2020-04-10 15:02:13 +02:00
|
|
|
// lhs.rhs
|
2021-06-02 08:29:18 +02:00
|
|
|
(lhs, rhs) => { optimize_expr(lhs, state, false); optimize_expr(rhs, state, true); }
|
2020-04-10 15:02:13 +02:00
|
|
|
}
|
2021-06-02 08:29:18 +02:00
|
|
|
// ....lhs.rhs
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Dot(x,_, ..) => { optimize_expr(&mut x.lhs, state, false); optimize_expr(&mut x.rhs, state, _chaining); }
|
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"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Index(x, ..) if !_chaining => match (&mut x.lhs, &mut x.rhs) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// array[int]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::Array(a, pos), Expr::IntegerConstant(i, ..)) if *i >= 0 && (*i as usize) < a.len() && a.iter().all(Expr::is_pure) => {
|
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();
|
2021-06-16 12:36:33 +02:00
|
|
|
let mut result = mem::take(&mut a[*i as usize]);
|
2020-11-12 05:37:42 +01:00
|
|
|
result.set_position(*pos);
|
|
|
|
*expr = result;
|
2020-04-10 15:02:13 +02:00
|
|
|
}
|
2021-04-10 09:00:03 +02:00
|
|
|
// array[-int]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::Array(a, pos), Expr::IntegerConstant(i, ..)) if *i < 0 && i.checked_abs().map(|n| n as usize <= a.len()).unwrap_or(false) && a.iter().all(Expr::is_pure) => {
|
2021-04-10 09:00:03 +02:00
|
|
|
// Array literal where everything is pure - promote the indexed item.
|
|
|
|
// All other items can be thrown away.
|
|
|
|
state.set_dirty();
|
2021-06-16 12:36:33 +02:00
|
|
|
let index = a.len() - i.abs() as usize;
|
|
|
|
let mut result = mem::take(&mut a[index]);
|
2021-04-10 09:00:03 +02:00
|
|
|
result.set_position(*pos);
|
|
|
|
*expr = result;
|
|
|
|
}
|
2020-04-10 15:02:13 +02:00
|
|
|
// map[string]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::Map(m, pos), 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();
|
2022-02-08 02:02:15 +01:00
|
|
|
*expr = mem::take(&mut m.0).into_iter().find(|(x, ..)| x.name.as_str() == s.as_str())
|
|
|
|
.map(|(.., mut expr)| { expr.set_position(*pos); expr })
|
2020-11-12 05:37:42 +01:00
|
|
|
.unwrap_or_else(|| Expr::Unit(*pos));
|
2020-03-10 10:10:33 +01:00
|
|
|
}
|
2021-06-02 08:29:18 +02:00
|
|
|
// int[int]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::IntegerConstant(n, pos), Expr::IntegerConstant(i, ..)) if *i >= 0 && (*i as usize) < (std::mem::size_of_val(n) * 8) => {
|
2021-06-02 08:29:18 +02:00
|
|
|
// Bit-field literal indexing - get the bit
|
|
|
|
state.set_dirty();
|
|
|
|
*expr = Expr::BoolConstant((*n & (1 << (*i as usize))) != 0, *pos);
|
|
|
|
}
|
|
|
|
// int[-int]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::IntegerConstant(n, pos), Expr::IntegerConstant(i, ..)) if *i < 0 && i.checked_abs().map(|i| i as usize <= (std::mem::size_of_val(n) * 8)).unwrap_or(false) => {
|
2021-06-02 08:29:18 +02:00
|
|
|
// Bit-field literal indexing - get the bit
|
|
|
|
state.set_dirty();
|
|
|
|
*expr = Expr::BoolConstant((*n & (1 << (std::mem::size_of_val(n) * 8 - i.abs() as usize))) != 0, *pos);
|
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// string[int]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::StringConstant(s, pos), Expr::IntegerConstant(i, ..)) if *i >= 0 && (*i as usize) < s.chars().count() => {
|
2020-03-16 05:41:52 +01:00
|
|
|
// String literal indexing - get the character
|
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
*expr = Expr::CharConstant(s.chars().nth(*i as usize).unwrap(), *pos);
|
2020-03-16 05:41:52 +01:00
|
|
|
}
|
2021-04-10 09:00:03 +02:00
|
|
|
// string[-int]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::StringConstant(s, pos), Expr::IntegerConstant(i, ..)) if *i < 0 && i.checked_abs().map(|n| n as usize <= s.chars().count()).unwrap_or(false) => {
|
2021-04-10 09:00:03 +02:00
|
|
|
// String literal indexing - get the character
|
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
*expr = Expr::CharConstant(s.chars().rev().nth(i.abs() as usize - 1).unwrap(), *pos);
|
2021-04-10 09:00:03 +02:00
|
|
|
}
|
2020-11-03 06:08:19 +01:00
|
|
|
// var[rhs]
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::Variable(..), rhs) => optimize_expr(rhs, state, true),
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs[rhs]
|
2021-06-02 08:29:18 +02:00
|
|
|
(lhs, rhs) => { optimize_expr(lhs, state, false); optimize_expr(rhs, state, true); }
|
2020-03-10 10:10:33 +01:00
|
|
|
},
|
2021-06-02 08:29:18 +02:00
|
|
|
// ...[lhs][rhs]
|
|
|
|
#[cfg(not(feature = "no_index"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Index(x, ..) => { optimize_expr(&mut x.lhs, state, false); optimize_expr(&mut x.rhs, state, _chaining); }
|
2021-04-04 07:13:07 +02:00
|
|
|
// ``
|
2021-06-29 12:41:03 +02:00
|
|
|
Expr::InterpolatedString(x, pos) if x.is_empty() => {
|
2021-04-04 07:13:07 +02:00
|
|
|
state.set_dirty();
|
2021-09-26 15:30:33 +02:00
|
|
|
*expr = Expr::StringConstant(state.engine.const_empty_string(), *pos);
|
2021-04-04 07:13:07 +02:00
|
|
|
}
|
|
|
|
// `...`
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::InterpolatedString(x, ..) if x.len() == 1 && matches!(x[0], Expr::StringConstant(..)) => {
|
2021-04-04 07:13:07 +02:00
|
|
|
state.set_dirty();
|
|
|
|
*expr = mem::take(&mut x[0]);
|
|
|
|
}
|
|
|
|
// `... ${ ... } ...`
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::InterpolatedString(x, ..) => {
|
2021-09-20 16:36:10 +02:00
|
|
|
x.iter_mut().for_each(|expr| optimize_expr(expr, state, false));
|
|
|
|
|
2021-06-16 12:36:33 +02:00
|
|
|
let mut n = 0;
|
2021-04-04 07:13:07 +02:00
|
|
|
|
|
|
|
// Merge consecutive strings
|
2021-12-15 16:21:05 +01:00
|
|
|
while n < x.len() - 1 {
|
2021-04-04 07:13:07 +02:00
|
|
|
match (mem::take(&mut x[n]), mem::take(&mut x[n+1])) {
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::StringConstant(mut s1, pos), Expr::StringConstant(s2, ..)) => { s1 += s2; x[n] = Expr::StringConstant(s1, pos); x.remove(n+1); state.set_dirty(); }
|
2022-02-10 10:55:32 +01:00
|
|
|
(expr1, Expr::Unit(..)) => { x[n] = expr1; x.remove(n+1); state.set_dirty(); }
|
2022-02-08 02:46:14 +01:00
|
|
|
(Expr::Unit(..), expr2) => { x[n+1] = expr2; x.remove(n); state.set_dirty(); }
|
2022-02-08 02:02:15 +01:00
|
|
|
(expr1, Expr::StringConstant(s, ..)) if s.is_empty() => { x[n] = expr1; x.remove(n+1); state.set_dirty(); }
|
|
|
|
(Expr::StringConstant(s, ..), expr2) if s.is_empty()=> { x[n+1] = expr2; x.remove(n); state.set_dirty(); }
|
2021-12-15 16:21:05 +01:00
|
|
|
(expr1, expr2) => { x[n] = expr1; x[n+1] = expr2; n += 1; }
|
2021-04-04 07:13:07 +02:00
|
|
|
}
|
|
|
|
}
|
2021-05-05 12:38:52 +02:00
|
|
|
|
|
|
|
x.shrink_to_fit();
|
2021-04-04 07:13:07 +02:00
|
|
|
}
|
2020-11-14 12:04:49 +01:00
|
|
|
// [ constant .. ]
|
|
|
|
#[cfg(not(feature = "no_index"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Array(..) if expr.is_constant() => {
|
2020-11-14 12:04:49 +01:00
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
*expr = Expr::DynamicConstant(expr.get_literal_value().unwrap().into(), expr.position());
|
2020-11-14 12:04:49 +01:00
|
|
|
}
|
2020-03-18 03:36:50 +01:00
|
|
|
// [ items .. ]
|
2020-03-10 10:10:33 +01:00
|
|
|
#[cfg(not(feature = "no_index"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Array(x, ..) => x.iter_mut().for_each(|expr| optimize_expr(expr, state, false)),
|
2020-11-14 12:04:49 +01:00
|
|
|
// #{ key:constant, .. }
|
|
|
|
#[cfg(not(feature = "no_object"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Map(..) if expr.is_constant() => {
|
2020-11-14 12:04:49 +01:00
|
|
|
state.set_dirty();
|
2022-01-06 04:07:52 +01:00
|
|
|
*expr = Expr::DynamicConstant(expr.get_literal_value().unwrap().into(), expr.position());
|
2020-11-14 12:04:49 +01:00
|
|
|
}
|
2020-11-12 05:37:42 +01:00
|
|
|
// #{ key:value, .. }
|
2020-03-29 17:53:35 +02:00
|
|
|
#[cfg(not(feature = "no_object"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Map(x, ..) => x.0.iter_mut().for_each(|(.., expr)| optimize_expr(expr, state, false)),
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs && rhs
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::And(x, ..) => match (&mut x.lhs, &mut x.rhs) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// true && rhs -> rhs
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::BoolConstant(true, ..), rhs) => { state.set_dirty(); optimize_expr(rhs, state, false); *expr = mem::take(rhs); }
|
2020-03-18 03:36:50 +01:00
|
|
|
// false && rhs -> false
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::BoolConstant(false, pos), ..) => { state.set_dirty(); *expr = Expr::BoolConstant(false, *pos); }
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs && true -> lhs
|
2022-02-08 02:02:15 +01:00
|
|
|
(lhs, Expr::BoolConstant(true, ..)) => { state.set_dirty(); optimize_expr(lhs, state, false); *expr = mem::take(lhs); }
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs && rhs
|
2021-12-15 16:21:05 +01:00
|
|
|
(lhs, rhs) => { optimize_expr(lhs, state, false); optimize_expr(rhs, state, false); }
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs || rhs
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Or(ref mut x, ..) => match (&mut x.lhs, &mut x.rhs) {
|
2020-03-18 03:36:50 +01:00
|
|
|
// false || rhs -> rhs
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::BoolConstant(false, ..), rhs) => { state.set_dirty(); optimize_expr(rhs, state, false); *expr = mem::take(rhs); }
|
2020-03-18 03:36:50 +01:00
|
|
|
// true || rhs -> true
|
2022-02-08 02:02:15 +01:00
|
|
|
(Expr::BoolConstant(true, pos), ..) => { state.set_dirty(); *expr = Expr::BoolConstant(true, *pos); }
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs || false
|
2022-02-08 02:02:15 +01:00
|
|
|
(lhs, Expr::BoolConstant(false, ..)) => { state.set_dirty(); optimize_expr(lhs, state, false); *expr = mem::take(lhs); }
|
2020-03-18 03:36:50 +01:00
|
|
|
// lhs || rhs
|
2021-12-15 16:21:05 +01:00
|
|
|
(lhs, rhs) => { optimize_expr(lhs, state, false); optimize_expr(rhs, state, false); }
|
2020-03-09 14:57:07 +01:00
|
|
|
},
|
2020-03-11 16:43:10 +01:00
|
|
|
|
2021-01-12 16:52:50 +01:00
|
|
|
// eval!
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::FnCall(x, ..) if x.name == KEYWORD_EVAL => {
|
2021-01-12 16:52:50 +01:00
|
|
|
state.propagate_constants = false;
|
|
|
|
}
|
2021-04-06 06:26:38 +02:00
|
|
|
// Fn
|
|
|
|
Expr::FnCall(x, pos)
|
2021-04-20 17:28:04 +02:00
|
|
|
if !x.is_qualified() // Non-qualified
|
2021-04-06 06:26:38 +02:00
|
|
|
&& state.optimization_level == OptimizationLevel::Simple // simple optimizations
|
2021-06-08 08:46:49 +02:00
|
|
|
&& x.args.len() == 1
|
2021-04-06 06:26:38 +02:00
|
|
|
&& x.name == KEYWORD_FN_PTR
|
2021-12-02 05:49:57 +01:00
|
|
|
&& x.args[0].is_constant()
|
2021-04-06 06:26:38 +02:00
|
|
|
=> {
|
2021-06-08 08:46:49 +02:00
|
|
|
let fn_name = match x.args[0] {
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Stack(slot, ..) => x.constants[slot].clone(),
|
|
|
|
Expr::StringConstant(ref s, ..) => s.clone().into(),
|
2021-12-02 05:49:57 +01:00
|
|
|
_ => Dynamic::UNIT
|
2021-06-08 08:46:49 +02:00
|
|
|
};
|
|
|
|
|
2021-12-02 05:49:57 +01:00
|
|
|
if let Ok(fn_ptr) = fn_name.into_immutable_string().map_err(|err| err.into()).and_then(FnPtr::try_from) {
|
|
|
|
state.set_dirty();
|
|
|
|
*expr = Expr::DynamicConstant(Box::new(fn_ptr.into()), *pos);
|
|
|
|
} else {
|
|
|
|
optimize_expr(&mut x.args[0], state, false);
|
2021-06-08 08:46:49 +02:00
|
|
|
}
|
2021-04-06 06:26:38 +02:00
|
|
|
}
|
|
|
|
|
2020-04-01 03:51:33 +02:00
|
|
|
// Do not call some special keywords
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::FnCall(x, ..) if DONT_EVAL_KEYWORDS.contains(&x.name.as_ref()) => {
|
2021-06-02 08:29:18 +02:00
|
|
|
x.args.iter_mut().for_each(|a| optimize_expr(a, state, false));
|
2020-05-09 15:46:38 +02:00
|
|
|
}
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2020-10-09 05:15:25 +02:00
|
|
|
// Call built-in operators
|
2020-11-12 05:37:42 +01:00
|
|
|
Expr::FnCall(x, pos)
|
2021-04-20 17:28:04 +02:00
|
|
|
if !x.is_qualified() // Non-qualified
|
2020-10-05 04:27:31 +02:00
|
|
|
&& state.optimization_level == OptimizationLevel::Simple // simple optimizations
|
2020-10-31 07:13:45 +01:00
|
|
|
&& x.args.iter().all(Expr::is_constant) // all arguments are constants
|
2021-03-09 06:44:54 +01:00
|
|
|
//&& !is_valid_identifier(x.name.chars()) // cannot be scripted
|
2020-10-05 04:27:31 +02:00
|
|
|
=> {
|
2021-07-14 07:57:58 +02:00
|
|
|
let arg_values = &mut x.args.iter().map(|e| match e {
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Stack(slot, ..) => x.constants[*slot].clone(),
|
2022-01-06 04:07:52 +01:00
|
|
|
_ => e.get_literal_value().unwrap()
|
2021-07-14 07:57:58 +02:00
|
|
|
}).collect::<StaticVec<_>>();
|
2021-03-28 13:04:25 +02:00
|
|
|
|
2020-10-05 04:27:31 +02:00
|
|
|
let arg_types: StaticVec<_> = arg_values.iter().map(Dynamic::type_id).collect();
|
|
|
|
|
2021-11-01 02:42:22 +01:00
|
|
|
match x.name.as_str() {
|
|
|
|
KEYWORD_TYPE_OF if arg_values.len() == 1 => {
|
|
|
|
state.set_dirty();
|
|
|
|
*expr = Expr::from_dynamic(state.engine.map_type_name(arg_values[0].type_name()).into(), *pos);
|
|
|
|
return;
|
2021-11-01 03:07:45 +01:00
|
|
|
}
|
2021-07-14 16:33:47 +02:00
|
|
|
#[cfg(not(feature = "no_closure"))]
|
2021-12-02 05:49:46 +01:00
|
|
|
crate::engine::KEYWORD_IS_SHARED if arg_values.len() == 1 => {
|
2021-11-01 02:42:22 +01:00
|
|
|
state.set_dirty();
|
|
|
|
*expr = Expr::from_dynamic(Dynamic::FALSE, *pos);
|
|
|
|
return;
|
|
|
|
}
|
2021-07-14 07:57:58 +02:00
|
|
|
// Overloaded operators can override built-in.
|
2021-12-27 15:28:11 +01:00
|
|
|
_ if x.args.len() == 2 && !has_native_fn_override(state.engine, x.hashes.native, arg_types.as_ref()) => {
|
2021-11-01 02:42:22 +01:00
|
|
|
if let Some(result) = get_builtin_binary_op_fn(x.name.as_ref(), &arg_values[0], &arg_values[1])
|
2021-07-14 07:57:58 +02:00
|
|
|
.and_then(|f| {
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
let lib = state.lib;
|
|
|
|
#[cfg(feature = "no_function")]
|
|
|
|
let lib = &[];
|
|
|
|
|
|
|
|
let context = (state.engine, x.name.as_str(), lib).into();
|
2022-01-06 04:07:52 +01:00
|
|
|
let (first, second) = arg_values.split_first_mut().unwrap();
|
2021-11-05 12:35:33 +01:00
|
|
|
(f)(context, &mut [ first, &mut second[0] ]).ok()
|
2021-11-01 02:42:22 +01:00
|
|
|
}) {
|
|
|
|
state.set_dirty();
|
|
|
|
*expr = Expr::from_dynamic(result, *pos);
|
|
|
|
return;
|
|
|
|
}
|
2020-10-05 04:27:31 +02:00
|
|
|
}
|
2021-11-01 02:42:22 +01:00
|
|
|
_ => ()
|
2020-10-05 04:27:31 +02:00
|
|
|
}
|
|
|
|
|
2021-06-02 08:29:18 +02:00
|
|
|
x.args.iter_mut().for_each(|a| optimize_expr(a, state, false));
|
2021-03-28 13:04:25 +02:00
|
|
|
|
2021-06-08 08:46:49 +02:00
|
|
|
// Move constant arguments
|
2021-11-15 07:30:00 +01:00
|
|
|
let constants = &mut x.constants;
|
|
|
|
x.args.iter_mut().for_each(|arg| {
|
2021-06-10 04:16:39 +02:00
|
|
|
if let Some(value) = arg.get_literal_value() {
|
2021-06-08 08:46:49 +02:00
|
|
|
state.set_dirty();
|
2021-11-15 07:30:00 +01:00
|
|
|
constants.push(value);
|
2022-02-04 05:04:33 +01:00
|
|
|
*arg = Expr::Stack(constants.len()-1, arg.start_position());
|
2021-06-08 08:46:49 +02:00
|
|
|
}
|
2021-11-15 07:30:00 +01:00
|
|
|
});
|
2020-10-05 04:27:31 +02:00
|
|
|
}
|
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// Eagerly call functions
|
2020-11-12 05:37:42 +01:00
|
|
|
Expr::FnCall(x, pos)
|
2022-03-04 05:22:44 +01:00
|
|
|
if !x.is_qualified() // non-qualified
|
2020-05-09 15:46:38 +02:00
|
|
|
&& state.optimization_level == OptimizationLevel::Full // full optimizations
|
2020-10-31 07:13:45 +01:00
|
|
|
&& x.args.iter().all(Expr::is_constant) // all arguments are constants
|
2020-03-17 03:27:43 +01:00
|
|
|
=> {
|
2020-10-05 04:27:31 +02:00
|
|
|
// First search for script-defined functions (can override built-in)
|
2020-10-05 06:09:45 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2021-11-27 16:04:45 +01:00
|
|
|
let has_script_fn = state.lib.iter().any(|&m| m.get_script_fn(&x.name, x.args.len()).is_some());
|
2020-10-05 06:09:45 +02:00
|
|
|
#[cfg(feature = "no_function")]
|
|
|
|
let has_script_fn = false;
|
2020-03-19 15:29:02 +01:00
|
|
|
|
2020-10-05 04:27:31 +02:00
|
|
|
if !has_script_fn {
|
2021-07-14 07:57:58 +02:00
|
|
|
let arg_values = &mut x.args.iter().map(|e| match e {
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Stack(slot, ..) => x.constants[*slot].clone(),
|
2022-01-06 04:07:52 +01:00
|
|
|
_ => e.get_literal_value().unwrap()
|
2021-07-14 07:57:58 +02:00
|
|
|
}).collect::<StaticVec<_>>();
|
|
|
|
|
|
|
|
let result = match x.name.as_str() {
|
|
|
|
KEYWORD_TYPE_OF if arg_values.len() == 1 => Some(state.engine.map_type_name(arg_values[0].type_name()).into()),
|
2021-07-14 16:33:47 +02:00
|
|
|
#[cfg(not(feature = "no_closure"))]
|
2021-12-02 05:49:46 +01:00
|
|
|
crate::engine::KEYWORD_IS_SHARED if arg_values.len() == 1 => Some(Dynamic::FALSE),
|
2021-11-27 16:04:45 +01:00
|
|
|
_ => state.call_fn_with_constant_arguments(&x.name, arg_values)
|
2020-10-05 04:27:31 +02:00
|
|
|
};
|
|
|
|
|
2021-07-14 07:57:58 +02:00
|
|
|
if let Some(result) = result {
|
2020-06-01 09:25:22 +02:00
|
|
|
state.set_dirty();
|
2021-07-14 07:57:58 +02:00
|
|
|
*expr = Expr::from_dynamic(result, *pos);
|
2020-11-12 05:37:42 +01:00
|
|
|
return;
|
2020-10-05 04:27:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-02 08:29:18 +02:00
|
|
|
x.args.iter_mut().for_each(|a| optimize_expr(a, state, false));
|
2020-03-15 15:39:58 +01:00
|
|
|
}
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2022-03-04 05:22:44 +01:00
|
|
|
// id(args ..) or xxx.id(args ..) -> optimize function call arguments
|
|
|
|
Expr::FnCall(x, ..) | Expr::MethodCall(x, ..) => for arg in x.args.iter_mut() {
|
2021-06-08 08:46:49 +02:00
|
|
|
optimize_expr(arg, state, false);
|
2021-03-28 13:04:25 +02:00
|
|
|
|
2021-06-08 08:46:49 +02:00
|
|
|
// Move constant arguments
|
2021-06-10 04:16:39 +02:00
|
|
|
if let Some(value) = arg.get_literal_value() {
|
2021-06-08 08:46:49 +02:00
|
|
|
state.set_dirty();
|
|
|
|
x.constants.push(value);
|
2022-02-04 05:04:33 +01:00
|
|
|
*arg = Expr::Stack(x.constants.len()-1, arg.start_position());
|
2021-03-28 13:04:25 +02:00
|
|
|
}
|
2021-06-08 08:46:49 +02:00
|
|
|
},
|
2020-03-19 12:53:42 +01:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// constant-name
|
2022-01-29 04:09:43 +01:00
|
|
|
#[cfg(not(feature = "no_module"))]
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Variable(.., x) if x.1.is_some() => (),
|
|
|
|
Expr::Variable(.., pos, x) if state.find_constant(&x.2).is_some() => {
|
2020-03-13 11:12:41 +01:00
|
|
|
// Replace constant with value
|
2022-01-06 04:07:52 +01:00
|
|
|
*expr = Expr::from_dynamic(state.find_constant(&x.2).unwrap().clone(), *pos);
|
2021-05-16 15:21:13 +02:00
|
|
|
state.set_dirty();
|
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
|
2022-02-08 02:02:15 +01:00
|
|
|
Expr::Custom(x, ..) => {
|
2021-07-04 10:31:01 +02:00
|
|
|
if x.scope_may_be_changed {
|
2021-01-12 16:52:50 +01:00
|
|
|
state.propagate_constants = false;
|
|
|
|
}
|
2021-10-25 16:41:42 +02:00
|
|
|
x.inputs.iter_mut().for_each(|expr| optimize_expr(expr, state, false));
|
2021-01-12 16:52:50 +01:00
|
|
|
}
|
2020-07-09 13:54:28 +02:00
|
|
|
|
2020-03-18 03:36:50 +01:00
|
|
|
// All other expressions - skip
|
2020-11-12 05:37:42 +01:00
|
|
|
_ => (),
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-26 16:21:16 +01:00
|
|
|
/// Optimize a block of [statements][Stmt] at top level.
|
2021-11-08 15:16:28 +01:00
|
|
|
///
|
|
|
|
/// Constants and variables from the scope are added.
|
2020-11-25 02:36:06 +01:00
|
|
|
fn optimize_top_level(
|
2022-02-16 05:57:26 +01:00
|
|
|
statements: StmtBlockContainer,
|
2020-04-16 17:31:48 +02:00
|
|
|
engine: &Engine,
|
2020-04-07 07:23:06 +02:00
|
|
|
scope: &Scope,
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))] lib: &[&crate::Module],
|
2021-03-11 11:29:22 +01:00
|
|
|
optimization_level: OptimizationLevel,
|
2022-02-16 05:57:26 +01:00
|
|
|
) -> StmtBlockContainer {
|
2021-08-13 07:42:39 +02:00
|
|
|
let mut statements = statements;
|
|
|
|
|
2020-03-15 15:39:58 +01:00
|
|
|
// If optimization level is None then skip optimizing
|
2021-03-11 11:29:22 +01:00
|
|
|
if optimization_level == OptimizationLevel::None {
|
2020-11-15 06:49:54 +01:00
|
|
|
statements.shrink_to_fit();
|
2020-03-15 15:39:58 +01:00
|
|
|
return statements;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set up the state
|
2021-11-29 02:43:35 +01:00
|
|
|
let mut state = OptimizerState::new(
|
|
|
|
engine,
|
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
lib,
|
|
|
|
optimization_level,
|
|
|
|
);
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2020-12-08 15:20:29 +01:00
|
|
|
// Add constants and variables from the scope
|
2022-01-28 11:59:18 +01:00
|
|
|
for (name, constant, value) in scope.iter() {
|
2020-12-08 15:20:29 +01:00
|
|
|
if !constant {
|
2021-05-16 15:21:13 +02:00
|
|
|
state.push_var(name, AccessMode::ReadWrite, None);
|
2020-12-08 15:20:29 +01:00
|
|
|
} else {
|
2021-05-16 15:21:13 +02:00
|
|
|
state.push_var(name, AccessMode::ReadOnly, Some(value));
|
2020-12-08 15:20:29 +01:00
|
|
|
}
|
2022-01-28 11:59:18 +01:00
|
|
|
}
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2022-02-16 05:57:26 +01:00
|
|
|
optimize_stmt_block(statements, &mut state, true, false, true)
|
2020-03-09 14:57:07 +01:00
|
|
|
}
|
2020-03-15 15:39:58 +01:00
|
|
|
|
2020-11-25 02:36:06 +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,
|
2022-02-16 05:57:26 +01:00
|
|
|
statements: StmtBlockContainer,
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))] functions: StaticVec<
|
|
|
|
crate::Shared<crate::ast::ScriptFnDef>,
|
|
|
|
>,
|
2021-03-11 11:29:22 +01:00
|
|
|
optimization_level: OptimizationLevel,
|
2020-03-15 15:39:58 +01:00
|
|
|
) -> AST {
|
2021-08-13 07:42:39 +02:00
|
|
|
let mut statements = statements;
|
|
|
|
|
2020-09-24 17:32:54 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
let lib = {
|
2021-11-29 02:43:35 +01:00
|
|
|
let mut module = crate::Module::new();
|
2020-05-10 15:25:47 +02:00
|
|
|
|
2021-11-29 03:17:04 +01:00
|
|
|
if optimization_level != OptimizationLevel::None {
|
2020-06-05 09:14:42 +02:00
|
|
|
// We only need the script library's signatures for optimization purposes
|
2021-11-29 02:43:35 +01:00
|
|
|
let mut lib2 = crate::Module::new();
|
2020-06-05 09:14:42 +02:00
|
|
|
|
2022-01-28 11:59:18 +01:00
|
|
|
for fn_def in &functions {
|
|
|
|
lib2.set_script_fn(crate::ast::ScriptFnDef {
|
2020-11-25 02:36:06 +01:00
|
|
|
name: fn_def.name.clone(),
|
|
|
|
access: fn_def.access,
|
2021-11-28 03:49:48 +01:00
|
|
|
body: crate::ast::StmtBlock::NONE,
|
2020-11-25 02:36:06 +01:00
|
|
|
params: fn_def.params.clone(),
|
|
|
|
#[cfg(not(feature = "no_module"))]
|
2022-01-30 10:27:13 +01:00
|
|
|
environ: None,
|
2021-04-09 16:49:47 +02:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
#[cfg(feature = "metadata")]
|
2021-11-12 06:25:57 +01:00
|
|
|
comments: None,
|
2020-07-12 05:46:53 +02:00
|
|
|
});
|
2022-01-28 11:59:18 +01:00
|
|
|
}
|
2020-06-05 09:14:42 +02:00
|
|
|
|
2021-03-11 11:29:22 +01:00
|
|
|
let lib2 = &[&lib2];
|
|
|
|
|
2022-01-28 11:59:18 +01:00
|
|
|
for fn_def in functions {
|
|
|
|
let mut fn_def = crate::func::native::shared_take_or_clone(fn_def);
|
2021-03-12 07:11:08 +01:00
|
|
|
|
2022-01-28 11:59:18 +01:00
|
|
|
// Optimize the function body
|
|
|
|
let body = mem::take(&mut *fn_def.body);
|
2021-03-10 15:12:48 +01:00
|
|
|
|
2022-01-28 11:59:18 +01:00
|
|
|
*fn_def.body = optimize_top_level(body, engine, scope, lib2, optimization_level);
|
2021-03-10 15:12:48 +01:00
|
|
|
|
2022-01-28 11:59:18 +01:00
|
|
|
module.set_script_fn(fn_def);
|
|
|
|
}
|
2020-05-24 10:40:00 +02:00
|
|
|
} else {
|
2022-01-28 11:59:18 +01:00
|
|
|
for fn_def in functions {
|
2020-11-25 02:36:06 +01:00
|
|
|
module.set_script_fn(fn_def);
|
2022-01-28 11:59:18 +01:00
|
|
|
}
|
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-11-15 06:49:54 +01:00
|
|
|
statements.shrink_to_fit();
|
|
|
|
|
2020-05-05 09:00:10 +02:00
|
|
|
AST::new(
|
2021-11-29 03:17:04 +01:00
|
|
|
match optimization_level {
|
2020-04-04 16:00:44 +02:00
|
|
|
OptimizationLevel::None => statements,
|
2021-11-29 02:43:35 +01:00
|
|
|
OptimizationLevel::Simple | OptimizationLevel::Full => optimize_top_level(
|
|
|
|
statements,
|
|
|
|
engine,
|
|
|
|
&scope,
|
|
|
|
#[cfg(not(feature = "no_function"))]
|
|
|
|
&[&lib],
|
2021-11-29 03:17:04 +01:00
|
|
|
optimization_level,
|
2021-11-29 02:43:35 +01:00
|
|
|
),
|
2020-04-04 16:00:44 +02:00
|
|
|
},
|
2021-11-29 02:43:35 +01:00
|
|
|
#[cfg(not(feature = "no_function"))]
|
2020-05-05 09:00:10 +02:00
|
|
|
lib,
|
2020-03-15 15:39:58 +01:00
|
|
|
)
|
|
|
|
}
|