kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Factor tuples into structs to aid in understanding.

Browse Source
This commit is contained in:
Stephen Chung 2022-01-28 10:11:40 +08:00
parent b86dd3f586
commit 20baae71d4
11 changed files with 386 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -9,6 +9,11 @@ Bug fixes
* In `Scope::clone_visible`, constants are now properly cloned as constants.
Script-breaking changes
-----------------------
* For consistency, the `export` statement no longer exports multiple variables.
New features
------------

29
src/ast/expr.rs
View File

@ -33,6 +33,16 @@ pub struct BinaryExpr {
pub rhs: Expr,
}
impl From<(Expr, Expr)> for BinaryExpr {
#[inline(always)]
fn from(value: (Expr, Expr)) -> Self {
Self {
lhs: value.0,
rhs: value.1,
}
}
}
/// _(internals)_ A custom syntax expression.
/// Exported under the `internals` feature only.
#[derive(Debug, Clone, Hash)]
@ -362,11 +372,8 @@ pub enum Expr {
),
/// Property access - ((getter, hash), (setter, hash), prop)
Property(
Box<(
(Identifier, u64),
(Identifier, u64),
(ImmutableString, Position),
)>,
Box<((Identifier, u64), (Identifier, u64), ImmutableString)>,
Position,
),
/// Stack slot for function calls. See [`FnCallExpr`] for more details.
///
@ -436,7 +443,7 @@ impl fmt::Debug for Expr {
}
f.write_str(")")
}
Self::Property(x) => write!(f, "Property({})", (x.2).0),
Self::Property(x, _) => write!(f, "Property({})", x.2),
Self::Stack(x, _) => write!(f, "StackSlot({})", x),
Self::Stmt(x) => {
f.write_str("ExprStmtBlock")?;
@ -648,9 +655,9 @@ impl Expr {
| Self::FnCall(_, pos)
| Self::Index(_, _, pos)
| Self::Custom(_, pos)
| Self::InterpolatedString(_, pos) => *pos,
| Self::InterpolatedString(_, pos)
| Self::Property(_, pos) => *pos,
Self::Property(x) => (x.2).1,
Self::Stmt(x) => x.position(),
Self::And(x, _) | Self::Or(x, _) | Self::Dot(x, _, _) => x.lhs.position(),
@ -679,9 +686,9 @@ impl Expr {
| Self::Stack(_, pos)
| Self::FnCall(_, pos)
| Self::Custom(_, pos)
| Self::InterpolatedString(_, pos) => *pos = new_pos,
| Self::InterpolatedString(_, pos)
| Self::Property(_, pos) => *pos = new_pos,
Self::Property(x) => (x.2).1 = new_pos,
Self::Stmt(x) => x.set_position(new_pos),
}
@ -781,7 +788,7 @@ impl Expr {
_ => false,
},
Self::Property(_) => match token {
Self::Property(_, _) => match token {
#[cfg(not(feature = "no_index"))]
Token::LeftBracket => true,
Token::LeftParen => true,

2
src/ast/mod.rs
View File

@ -13,7 +13,7 @@ pub use flags::{FnAccess, OptionFlags, AST_OPTION_FLAGS};
pub use ident::Ident;
#[cfg(not(feature = "no_function"))]
pub use script_fn::{ScriptFnDef, ScriptFnMetadata};
pub use stmt::{OpAssignment, Stmt, StmtBlock};
pub use stmt::{ConditionalStmtBlock, OpAssignment, Stmt, StmtBlock, SwitchCases, TryCatchBlock};
#[cfg(not(feature = "no_float"))]
pub use expr::FloatWrapper;

146
src/ast/stmt.rs
View File

@ -1,6 +1,6 @@
//! Module defining script statements.
use super::{ASTNode, Expr, FnCallExpr, Ident, OptionFlags, AST_OPTION_FLAGS::*};
use super::{ASTNode, BinaryExpr, Expr, FnCallExpr, Ident, OptionFlags, AST_OPTION_FLAGS::*};
use crate::engine::KEYWORD_EVAL;
use crate::tokenizer::Token;
use crate::{calc_fn_hash, Position, StaticVec, INT};
@ -79,6 +79,58 @@ impl OpAssignment<'_> {
}
}
/// A statements block with an optional condition.
#[derive(Debug, Clone, Hash)]
pub struct ConditionalStmtBlock {
/// Optional condition.
pub condition: Option<Expr>,
/// Statements block.
pub statements: StmtBlock,
}
impl<B: Into<StmtBlock>> From<(Option<Expr>, B)> for ConditionalStmtBlock {
#[inline(always)]
fn from(value: (Option<Expr>, B)) -> Self {
Self {
condition: value.0,
statements: value.1.into(),
}
}
}
impl ConditionalStmtBlock {
/// Does the condition exist?
#[inline(always)]
#[must_use]
pub const fn has_condition(&self) -> bool {
self.condition.is_some()
}
}
/// _(internals)_ A type containing all cases for a `switch` statement.
/// Exported under the `internals` feature only.
#[derive(Debug, Clone, Hash)]
pub struct SwitchCases {
/// Dictionary mapping value hashes to [`ConditionalStmtBlock`]'s.
pub cases: BTreeMap<u64, Box<ConditionalStmtBlock>>,
/// Statements block for the default case (there can be no condition for the default case).
pub def_case: StmtBlock,
/// List of range cases.
pub ranges: StaticVec<(INT, INT, bool, ConditionalStmtBlock)>,
}
/// _(internals)_ A `try-catch` block.
/// Exported under the `internals` feature only.
#[derive(Debug, Clone, Hash)]
pub struct TryCatchBlock {
/// `try` block.
pub try_block: StmtBlock,
/// `catch` variable, if any.
pub catch_var: Option<Ident>,
/// `catch` block.
pub catch_block: StmtBlock,
}
/// _(internals)_ A scoped block of statements.
/// Exported under the `internals` feature only.
#[derive(Clone, Hash, Default)]
@ -160,6 +212,20 @@ impl DerefMut for StmtBlock {
}
}
impl AsRef<[Stmt]> for StmtBlock {
#[inline(always)]
fn as_ref(&self) -> &[Stmt] {
&self.0
}
}
impl AsMut<[Stmt]> for StmtBlock {
#[inline(always)]
fn as_mut(&mut self) -> &mut [Stmt] {
&mut self.0
}
}
impl fmt::Debug for StmtBlock {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Block")?;
@ -214,15 +280,7 @@ pub enum Stmt {
/// 0) Hash table for (condition, block)
/// 1) Default block
/// 2) List of ranges: (start, end, inclusive, condition, statement)
Switch(
Expr,
Box<(
BTreeMap<u64, Box<(Option<Expr>, StmtBlock)>>,
StmtBlock,
StaticVec<(INT, INT, bool, Option<Expr>, StmtBlock)>,
)>,
Position,
),
Switch(Expr, Box<SwitchCases>, Position),
/// `while` expr `{` stmt `}` | `loop` `{` stmt `}`
///
/// If the guard expression is [`UNIT`][Expr::Unit], then it is a `loop` statement.
@ -244,7 +302,7 @@ pub enum Stmt {
/// * [`AST_OPTION_CONSTANT`] = `const`
Var(Expr, Box<Ident>, OptionFlags, Position),
/// expr op`=` expr
Assignment(Box<(Expr, Option<OpAssignment<'static>>, Expr)>, Position),
Assignment(Box<(Option<OpAssignment<'static>>, BinaryExpr)>, Position),
/// func `(` expr `,` ... `)`
///
/// Note - this is a duplicate of [`Expr::FnCall`] to cover the very common pattern of a single
@ -253,7 +311,7 @@ pub enum Stmt {
/// `{` stmt`;` ... `}`
Block(Box<[Stmt]>, Position),
/// `try` `{` stmt; ... `}` `catch` `(` var `)` `{` stmt; ... `}`
TryCatch(Box<(StmtBlock, Option<Ident>, StmtBlock)>, Position),
TryCatch(Box<TryCatchBlock>, Position),
/// [expression][Expr]
Expr(Expr),
/// `continue`/`break`
@ -275,11 +333,11 @@ pub enum Stmt {
/// Not available under `no_module`.
#[cfg(not(feature = "no_module"))]
Import(Expr, Option<Box<Ident>>, Position),
/// `export` var `as` var `,` ...
/// `export` var `as` var
///
/// Not available under `no_module`.
#[cfg(not(feature = "no_module"))]
Export(Box<[(Ident, Ident)]>, Position),
Export(Box<(Ident, Ident)>, Position),
/// Convert a variable to shared.
///
/// Not available under `no_closure`.
@ -443,20 +501,20 @@ impl Stmt {
Self::Expr(expr) => expr.is_pure(),
Self::If(condition, x, _) => {
condition.is_pure()
&& (x.0).0.iter().all(Stmt::is_pure)
&& (x.1).0.iter().all(Stmt::is_pure)
&& x.0.iter().all(Stmt::is_pure)
&& x.1.iter().all(Stmt::is_pure)
}
Self::Switch(expr, x, _) => {
expr.is_pure()
&& x.0.values().all(|block| {
block.0.as_ref().map(Expr::is_pure).unwrap_or(true)
&& (block.1).0.iter().all(Stmt::is_pure)
&& x.cases.values().all(|block| {
block.condition.as_ref().map(Expr::is_pure).unwrap_or(true)
&& block.statements.iter().all(Stmt::is_pure)
})
&& (x.2).iter().all(|(_, _, _, condition, stmt)| {
condition.as_ref().map(Expr::is_pure).unwrap_or(true)
&& stmt.0.iter().all(Stmt::is_pure)
&& x.ranges.iter().all(|(_, _, _, block)| {
block.condition.as_ref().map(Expr::is_pure).unwrap_or(true)
&& block.statements.iter().all(Stmt::is_pure)
})
&& (x.1).0.iter().all(Stmt::is_pure)
&& x.def_case.iter().all(Stmt::is_pure)
}
// Loops that exit can be pure because it can never be infinite.
@ -472,13 +530,13 @@ impl Stmt {
// For loops can be pure because if the iterable is pure, it is finite,
// so infinite loops can never occur.
Self::For(iterable, x, _) => iterable.is_pure() && (x.2).0.iter().all(Stmt::is_pure),
Self::For(iterable, x, _) => iterable.is_pure() && x.2.iter().all(Stmt::is_pure),
Self::Var(_, _, _, _) | Self::Assignment(_, _) | Self::FnCall(_, _) => false,
Self::Block(block, _) => block.iter().all(|stmt| stmt.is_pure()),
Self::BreakLoop(_, _) | Self::Return(_, _, _) => false,
Self::TryCatch(x, _) => {
(x.0).0.iter().all(Stmt::is_pure) && (x.2).0.iter().all(Stmt::is_pure)
x.try_block.iter().all(Stmt::is_pure) && x.catch_block.iter().all(Stmt::is_pure)
}
#[cfg(not(feature = "no_module"))]
@ -574,12 +632,12 @@ impl Stmt {
if !e.walk(path, on_node) {
return false;
}
for s in &(x.0).0 {
for s in x.0.iter() {
if !s.walk(path, on_node) {
return false;
}
}
for s in &(x.1).0 {
for s in x.1.iter() {
if !s.walk(path, on_node) {
return false;
}
@ -589,27 +647,37 @@ impl Stmt {
if !e.walk(path, on_node) {
return false;
}
for b in x.0.values() {
if !b.0.as_ref().map(|e| e.walk(path, on_node)).unwrap_or(true) {
for b in x.cases.values() {
if !b
.condition
.as_ref()
.map(|e| e.walk(path, on_node))
.unwrap_or(true)
{
return false;
}
for s in &(b.1).0 {
for s in b.statements.iter() {
if !s.walk(path, on_node) {
return false;
}
}
}
for (_, _, _, c, stmt) in &x.2 {
if !c.as_ref().map(|e| e.walk(path, on_node)).unwrap_or(true) {
for (_, _, _, b) in &x.ranges {
if !b
.condition
.as_ref()
.map(|e| e.walk(path, on_node))
.unwrap_or(true)
{
return false;
}
for s in &stmt.0 {
for s in b.statements.iter() {
if !s.walk(path, on_node) {
return false;
}
}
}
for s in &(x.1).0 {
for s in x.def_case.iter() {
if !s.walk(path, on_node) {
return false;
}
@ -629,17 +697,17 @@ impl Stmt {
if !e.walk(path, on_node) {
return false;
}
for s in &(x.2).0 {
for s in x.2.iter() {
if !s.walk(path, on_node) {
return false;
}
}
}
Self::Assignment(x, _) => {
if !x.0.walk(path, on_node) {
if !x.1.lhs.walk(path, on_node) {
return false;
}
if !x.2.walk(path, on_node) {
if !x.1.rhs.walk(path, on_node) {
return false;
}
}
@ -658,12 +726,12 @@ impl Stmt {
}
}
Self::TryCatch(x, _) => {
for s in &(x.0).0 {
for s in x.try_block.iter() {
if !s.walk(path, on_node) {
return false;
}
}
for s in &(x.2).0 {
for s in x.catch_block.iter() {
if !s.walk(path, on_node) {
return false;
}

52
src/eval/chaining.rs
View File

@ -290,13 +290,12 @@ impl Engine {
unreachable!("function call in dot chain should not be namespace-qualified")
}
// {xxx:map}.id op= ???
Expr::Property(x) if target.is::<crate::Map>() && new_val.is_some() => {
Expr::Property(x, pos) if target.is::<crate::Map>() && new_val.is_some() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, state, lib, this_ptr, rhs, level)?;
let (name, pos) = &x.2;
let index = x.2.clone().into();
let ((new_val, new_pos), (op_info, op_pos)) = new_val.expect("`Some`");
let index = name.into();
{
let val_target = &mut self.get_indexed_mut(
global, state, lib, target, index, *pos, true, false, level,
@ -311,23 +310,22 @@ impl Engine {
Ok((Dynamic::UNIT, true))
}
// {xxx:map}.id
Expr::Property(x) if target.is::<crate::Map>() => {
Expr::Property(x, pos) if target.is::<crate::Map>() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, state, lib, this_ptr, rhs, level)?;
let (name, pos) = &x.2;
let index = name.into();
let index = x.2.clone().into();
let val = self.get_indexed_mut(
global, state, lib, target, index, *pos, false, false, level,
)?;
Ok((val.take_or_clone(), false))
}
// xxx.id op= ???
Expr::Property(x) if new_val.is_some() => {
Expr::Property(x, pos) if new_val.is_some() => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, state, lib, this_ptr, rhs, level)?;
let ((getter, hash_get), (setter, hash_set), (name, pos)) = x.as_ref();
let ((getter, hash_get), (setter, hash_set), name) = x.as_ref();
let ((mut new_val, new_pos), (op_info, op_pos)) = new_val.expect("`Some`");
if op_info.is_some() {
@ -402,11 +400,11 @@ impl Engine {
})
}
// xxx.id
Expr::Property(x) => {
Expr::Property(x, pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(scope, global, state, lib, this_ptr, rhs, level)?;
let ((getter, hash_get), _, (name, pos)) = x.as_ref();
let ((getter, hash_get), _, name) = x.as_ref();
let hash = crate::ast::FnCallHashes::from_native(*hash_get);
let args = &mut [target.as_mut()];
self.exec_fn_call(
@ -442,16 +440,15 @@ impl Engine {
let _node = &x.lhs;
let val_target = &mut match x.lhs {
Expr::Property(ref p) => {
Expr::Property(ref p, pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(
scope, global, state, lib, this_ptr, _node, level,
)?;
let (name, pos) = &p.2;
let index = name.into();
let index = p.2.clone().into();
self.get_indexed_mut(
global, state, lib, target, index, *pos, false, true, level,
global, state, lib, target, index, pos, false, true, level,
)?
}
// {xxx:map}.fn_name(arg_expr_list)[expr] | {xxx:map}.fn_name(arg_expr_list).expr
@ -495,14 +492,13 @@ impl Engine {
match x.lhs {
// xxx.prop[expr] | xxx.prop.expr
Expr::Property(ref p) => {
Expr::Property(ref p, pos) => {
#[cfg(feature = "debugging")]
self.run_debugger(
scope, global, state, lib, this_ptr, _node, level,
)?;
let ((getter, hash_get), (setter, hash_set), (name, pos)) =
p.as_ref();
let ((getter, hash_get), (setter, hash_set), name) = p.as_ref();
let rhs_chain = rhs.into();
let hash_get = crate::ast::FnCallHashes::from_native(*hash_get);
let hash_set = crate::ast::FnCallHashes::from_native(*hash_set);
@ -513,15 +509,15 @@ impl Engine {
let (mut val, _) = self
.exec_fn_call(
global, state, lib, getter, hash_get, args, is_ref_mut,
true, *pos, None, level,
true, pos, None, level,
)
.or_else(|err| match *err {
// Try an indexer if property does not exist
ERR::ErrorDotExpr(_, _) => {
let prop = name.into();
self.get_indexed_mut(
global, state, lib, target, prop, *pos, false,
true, level,
global, state, lib, target, prop, pos, false, true,
level,
)
.map(|v| (v.take_or_clone(), false))
.map_err(
@ -561,7 +557,7 @@ impl Engine {
let args = &mut arg_values;
self.exec_fn_call(
global, state, lib, setter, hash_set, args, is_ref_mut,
true, *pos, None, level,
true, pos, None, level,
)
.or_else(
|err| match *err {
@ -576,7 +572,7 @@ impl Engine {
);
self.exec_fn_call(
global, state, lib, fn_name, hash_set, args,
is_ref_mut, true, *pos, None, level,
is_ref_mut, true, pos, None, level,
)
.or_else(|idx_err| match *idx_err {
ERR::ErrorIndexingType(_, _) => {
@ -754,10 +750,10 @@ impl Engine {
}
#[cfg(not(feature = "no_object"))]
Expr::Property(x) if _parent_chain_type == ChainType::Dotting => {
idx_values.push(super::ChainArgument::Property((x.2).1))
Expr::Property(_, pos) if _parent_chain_type == ChainType::Dotting => {
idx_values.push(super::ChainArgument::Property(*pos))
}
Expr::Property(_) => unreachable!("unexpected Expr::Property for indexing"),
Expr::Property(_, _) => unreachable!("unexpected Expr::Property for indexing"),
Expr::Index(x, term, _) | Expr::Dot(x, term, _) if !terminate_chaining => {
let crate::ast::BinaryExpr { lhs, rhs, .. } = x.as_ref();
@ -765,10 +761,10 @@ impl Engine {
// Evaluate in left-to-right order
let lhs_arg_val = match lhs {
#[cfg(not(feature = "no_object"))]
Expr::Property(x) if _parent_chain_type == ChainType::Dotting => {
super::ChainArgument::Property((x.2).1)
Expr::Property(_, pos) if _parent_chain_type == ChainType::Dotting => {
super::ChainArgument::Property(*pos)
}
Expr::Property(_) => unreachable!("unexpected Expr::Property for indexing"),
Expr::Property(_, _) => unreachable!("unexpected Expr::Property for indexing"),
#[cfg(not(feature = "no_object"))]
Expr::FnCall(x, _)

2
src/eval/debugger.rs
View File

@ -312,7 +312,7 @@ impl Debugger {
},
#[cfg(not(feature = "no_object"))]
BreakPoint::AtProperty { name, .. } => match node {
ASTNode::Expr(Expr::Property(x)) => (x.2).0 == *name,
ASTNode::Expr(Expr::Property(x, _)) => x.2 == *name,
_ => false,
},
})

87
src/eval/stmt.rs
View File

@ -1,7 +1,9 @@
//! Module defining functions for evaluating a statement.
use super::{EvalState, GlobalRuntimeState, Target};
use crate::ast::{Expr, Ident, OpAssignment, Stmt, AST_OPTION_FLAGS::*};
use crate::ast::{
BinaryExpr, Expr, Ident, OpAssignment, Stmt, SwitchCases, TryCatchBlock, AST_OPTION_FLAGS::*,
};
use crate::func::get_hasher;
use crate::types::dynamic::{AccessMode, Union};
use crate::{Dynamic, Engine, Module, Position, RhaiResult, RhaiResultOf, Scope, ERR, INT};
@ -225,20 +227,21 @@ impl Engine {
#[cfg(not(feature = "unchecked"))]
self.inc_operations(&mut global.num_operations, stmt.position())?;
let result = if x.0.is_variable_access(false) {
let (lhs_expr, op_info, rhs_expr) = x.as_ref();
let result = if x.1.lhs.is_variable_access(false) {
let (op_info, BinaryExpr { lhs, rhs }) = x.as_ref();
let rhs_result = self
.eval_expr(scope, global, state, lib, this_ptr, rhs_expr, level)
.eval_expr(scope, global, state, lib, this_ptr, rhs, level)
.map(Dynamic::flatten);
if let Ok(rhs_val) = rhs_result {
let search_result =
self.search_namespace(scope, global, state, lib, this_ptr, lhs_expr);
self.search_namespace(scope, global, state, lib, this_ptr, lhs);
if let Ok(search_val) = search_result {
let (mut lhs_ptr, pos) = search_val;
let var_name = lhs_expr.get_variable_name(false).expect("`Expr::Variable`");
let var_name = lhs.get_variable_name(false).expect("`Expr::Variable`");
if !lhs_ptr.is_ref() {
return Err(
@ -259,7 +262,7 @@ impl Engine {
(var_name, pos),
rhs_val,
)
.map_err(|err| err.fill_position(rhs_expr.position()))
.map_err(|err| err.fill_position(rhs.position()))
.map(|_| Dynamic::UNIT)
} else {
search_result.map(|_| Dynamic::UNIT)
@ -268,16 +271,17 @@ impl Engine {
rhs_result
}
} else {
let (lhs_expr, op_info, rhs_expr) = x.as_ref();
let (op_info, BinaryExpr { lhs, rhs }) = x.as_ref();
let rhs_result = self
.eval_expr(scope, global, state, lib, this_ptr, rhs_expr, level)
.eval_expr(scope, global, state, lib, this_ptr, rhs, level)
.map(Dynamic::flatten);
if let Ok(rhs_val) = rhs_result {
let _new_val = Some(((rhs_val, rhs_expr.position()), (*op_info, *op_pos)));
let _new_val = Some(((rhs_val, rhs.position()), (*op_info, *op_pos)));
// Must be either `var[index] op= val` or `var.prop op= val`
match lhs_expr {
match lhs {
// name op= rhs (handled above)
Expr::Variable(_, _, _) => {
unreachable!("Expr::Variable case is already handled")
@ -286,17 +290,17 @@ impl Engine {
#[cfg(not(feature = "no_index"))]
Expr::Index(_, _, _) => self
.eval_dot_index_chain(
scope, global, state, lib, this_ptr, lhs_expr, level, _new_val,
scope, global, state, lib, this_ptr, lhs, level, _new_val,
)
.map(|_| Dynamic::UNIT),
// dot_lhs.dot_rhs op= rhs
#[cfg(not(feature = "no_object"))]
Expr::Dot(_, _, _) => self
.eval_dot_index_chain(
scope, global, state, lib, this_ptr, lhs_expr, level, _new_val,
scope, global, state, lib, this_ptr, lhs, level, _new_val,
)
.map(|_| Dynamic::UNIT),
_ => unreachable!("cannot assign to expression: {:?}", lhs_expr),
_ => unreachable!("cannot assign to expression: {:?}", lhs),
}
} else {
rhs_result
@ -362,7 +366,11 @@ impl Engine {
// Switch statement
Stmt::Switch(match_expr, x, _) => {
let (table, def_stmt, ranges) = x.as_ref();
let SwitchCases {
cases,
def_case,
ranges,
} = x.as_ref();
let value_result =
self.eval_expr(scope, global, state, lib, this_ptr, match_expr, level);
@ -374,9 +382,9 @@ impl Engine {
let hash = hasher.finish();
// First check hashes
if let Some(t) = table.get(&hash) {
if let Some(t) = cases.get(&hash) {
let cond_result = t
.0
.condition
.as_ref()
.map(|cond| {
self.eval_expr(scope, global, state, lib, this_ptr, cond, level)
@ -392,7 +400,7 @@ impl Engine {
.unwrap_or(Ok(true));
match cond_result {
Ok(true) => Ok(Some(&t.1)),
Ok(true) => Ok(Some(&t.statements)),
Ok(false) => Ok(None),
_ => cond_result.map(|_| None),
}
@ -401,13 +409,14 @@ impl Engine {
let value = value.as_int().expect("`INT`");
let mut result = Ok(None);
for (_, _, _, condition, stmt_block) in
ranges.iter().filter(|&&(start, end, inclusive, _, _)| {
for (_, _, _, block) in
ranges.iter().filter(|&&(start, end, inclusive, _)| {
(!inclusive && (start..end).contains(&value))
|| (inclusive && (start..=end).contains(&value))
})
{
let cond_result = condition
let cond_result = block
.condition
.as_ref()
.map(|cond| {
self.eval_expr(
@ -425,7 +434,7 @@ impl Engine {
.unwrap_or(Ok(true));
match cond_result {
Ok(true) => result = Ok(Some(stmt_block)),
Ok(true) => result = Ok(Some(&block.statements)),
Ok(false) => continue,
_ => result = cond_result.map(|_| None),
}
@ -453,9 +462,9 @@ impl Engine {
}
} else if let Ok(None) = stmt_block_result {
// Default match clause
if !def_stmt.is_empty() {
if !def_case.is_empty() {
self.eval_stmt_block(
scope, global, state, lib, this_ptr, def_stmt, true, level,
scope, global, state, lib, this_ptr, def_case, true, level,
)
} else {
Ok(Dynamic::UNIT)
@ -685,10 +694,14 @@ impl Engine {
// Try/Catch statement
Stmt::TryCatch(x, _) => {
let (try_stmt, err_var_name, catch_stmt) = x.as_ref();
let TryCatchBlock {
try_block,
catch_var,
catch_block,
} = x.as_ref();
let result = self
.eval_stmt_block(scope, global, state, lib, this_ptr, try_stmt, true, level)
.eval_stmt_block(scope, global, state, lib, this_ptr, try_block, true, level)
.map(|_| Dynamic::UNIT);
match result {
@ -733,12 +746,19 @@ impl Engine {
let orig_scope_len = scope.len();
err_var_name
catch_var
.as_ref()
.map(|Ident { name, .. }| scope.push(name.clone(), err_value));
let result = self.eval_stmt_block(
scope, global, state, lib, this_ptr, catch_stmt, true, level,
scope,
global,
state,
lib,
this_ptr,
catch_block,
true,
level,
);
scope.rewind(orig_scope_len);
@ -896,21 +916,18 @@ impl Engine {
// Export statement
#[cfg(not(feature = "no_module"))]
Stmt::Export(list, _) => {
list.iter()
.try_for_each(|(Ident { name, pos, .. }, Ident { name: rename, .. })| {
Stmt::Export(x, _) => {
let (Ident { name, pos, .. }, Ident { name: alias, .. }) = x.as_ref();
// Mark scope variables as public
if let Some((index, _)) = scope.get_index(name) {
scope.add_entry_alias(
index,
if rename.is_empty() { name } else { rename }.clone(),
if alias.is_empty() { name } else { alias }.clone(),
);
Ok(()) as RhaiResultOf<_>
Ok(Dynamic::UNIT)
} else {
Err(ERR::ErrorVariableNotFound(name.to_string(), *pos).into())
}
})
.map(|_| Dynamic::UNIT)
}
// Share statement

5
src/lib.rs
View File

@ -254,8 +254,9 @@ pub use parser::ParseState;
#[cfg(feature = "internals")]
pub use ast::{
ASTNode, BinaryExpr, CustomExpr, Expr, FnCallExpr, FnCallHashes, Ident, OpAssignment,
OptionFlags, ScriptFnDef, Stmt, StmtBlock, AST_OPTION_FLAGS::*,
ASTNode, BinaryExpr, ConditionalStmtBlock, CustomExpr, Expr, FnCallExpr, FnCallHashes, Ident,
OpAssignment, OptionFlags, ScriptFnDef, Stmt, StmtBlock, SwitchCases, TryCatchBlock,
AST_OPTION_FLAGS::*,
};
#[cfg(feature = "internals")]

206
src/optimizer.rs
View File

@ -412,26 +412,26 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
match stmt {
// var = var op expr => var op= expr
Stmt::Assignment(x, _)
if x.1.is_none()
&& x.0.is_variable_access(true)
&& matches!(&x.2, Expr::FnCall(x2, _)
if x.0.is_none()
&& x.1.lhs.is_variable_access(true)
&& matches!(&x.1.rhs, Expr::FnCall(x2, _)
if Token::lookup_from_syntax(&x2.name).map(|t| t.has_op_assignment()).unwrap_or(false)
&& x2.args.len() == 2
&& x2.args[0].get_variable_name(true) == x.0.get_variable_name(true)
&& x2.args[0].get_variable_name(true) == x.1.lhs.get_variable_name(true)
) =>
{
match x.2 {
match x.1.rhs {
Expr::FnCall(ref mut x2, _) => {
state.set_dirty();
x.1 = Some(OpAssignment::new_from_base(&x2.name));
x.0 = Some(OpAssignment::new_from_base(&x2.name));
let value = mem::take(&mut x2.args[1]);
if let Expr::Stack(slot, pos) = value {
x.2 =
x.1.rhs =
Expr::from_dynamic(mem::take(x2.constants.get_mut(slot).unwrap()), pos);
} else {
x.2 = value;
x.1.rhs = value;
}
}
ref expr => unreachable!("Expr::FnCall expected but gets {:?}", expr),
@ -439,13 +439,12 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
}
// expr op= expr
Stmt::Assignment(x, _) => match x.0 {
Expr::Variable(_, _, _) => optimize_expr(&mut x.2, state, false),
_ => {
optimize_expr(&mut x.0, state, false);
optimize_expr(&mut x.2, state, false);
Stmt::Assignment(x, _) => {
if !x.1.lhs.is_variable_access(false) {
optimize_expr(&mut x.1.lhs, state, false);
}
optimize_expr(&mut x.1.rhs, state, false);
}
},
// if expr {}
Stmt::If(condition, x, _) if x.0.is_empty() && x.1.is_empty() => {
@ -502,66 +501,24 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
value.hash(hasher);
let hash = hasher.finish();
let table = &mut x.0;
let cases = &mut x.cases;
// First check hashes
if let Some(block) = table.get_mut(&hash) {
if let Some(mut condition) = mem::take(&mut block.0) {
if let Some(block) = cases.get_mut(&hash) {
if let Some(mut condition) = mem::take(&mut block.condition) {
// switch const { case if condition => stmt, _ => def } => if condition { stmt } else { def }
optimize_expr(&mut condition, state, false);
let def_stmt =
optimize_stmt_block(mem::take(&mut *x.1), state, true, true, false);
optimize_stmt_block(mem::take(&mut x.def_case), state, true, true, false);
*stmt = Stmt::If(
condition,
Box::new((
mem::take(&mut block.1),
Stmt::Block(def_stmt.into_boxed_slice(), x.1.position().or_else(*pos))
.into(),
)),
match_expr.position(),
);
} else {
// Promote the matched case
let statements =
optimize_stmt_block(mem::take(&mut *block.1), state, true, true, false);
*stmt = Stmt::Block(statements.into_boxed_slice(), block.1.position());
}
state.set_dirty();
return;
}
// Then check ranges
let ranges = &mut x.2;
if value.is::<INT>() && !ranges.is_empty() {
let value = value.as_int().expect("`INT`");
// Only one range or all ranges without conditions
if ranges.len() == 1 || ranges.iter().all(|(_, _, _, c, _)| c.is_none()) {
for (_, _, _, condition, stmt_block) in
ranges
.iter_mut()
.filter(|&&mut (start, end, inclusive, _, _)| {
(!inclusive && (start..end).contains(&value))
|| (inclusive && (start..=end).contains(&value))
})
{
if let Some(mut condition) = mem::take(condition) {
// switch const { range if condition => stmt, _ => def } => if condition { stmt } else { def }
optimize_expr(&mut condition, state, false);
let def_stmt =
optimize_stmt_block(mem::take(&mut *x.1), state, true, true, false);
*stmt = Stmt::If(
condition,
Box::new((
mem::take(stmt_block),
mem::take(&mut block.statements),
Stmt::Block(
def_stmt.into_boxed_slice(),
x.1.position().or_else(*pos),
x.def_case.position().or_else(*pos),
)
.into(),
)),
@ -569,11 +526,68 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
);
} else {
// Promote the matched case
let statements = mem::take(&mut **stmt_block);
let statements = optimize_stmt_block(
mem::take(&mut block.statements),
state,
true,
true,
false,
);
*stmt = Stmt::Block(statements.into_boxed_slice(), block.statements.position());
}
state.set_dirty();
return;
}
// Then check ranges
let ranges = &mut x.ranges;
if value.is::<INT>() && !ranges.is_empty() {
let value = value.as_int().expect("`INT`");
// Only one range or all ranges without conditions
if ranges.len() == 1 || ranges.iter().all(|(_, _, _, c)| !c.has_condition()) {
for (_, _, _, block) in
ranges
.iter_mut()
.filter(|&&mut (start, end, inclusive, _)| {
(!inclusive && (start..end).contains(&value))
|| (inclusive && (start..=end).contains(&value))
})
{
if let Some(mut condition) = mem::take(&mut block.condition) {
// switch const { range if condition => stmt, _ => def } => if condition { stmt } else { def }
optimize_expr(&mut condition, state, false);
let def_stmt = optimize_stmt_block(
mem::take(&mut x.def_case),
state,
true,
true,
false,
);
*stmt = Stmt::If(
condition,
Box::new((
mem::take(&mut block.statements),
Stmt::Block(
def_stmt.into_boxed_slice(),
x.def_case.position().or_else(*pos),
)
.into(),
)),
match_expr.position(),
);
} else {
// Promote the matched case
let statements = mem::take(&mut *block.statements);
let statements =
optimize_stmt_block(statements, state, true, true, false);
*stmt =
Stmt::Block(statements.into_boxed_slice(), stmt_block.position());
*stmt = Stmt::Block(
statements.into_boxed_slice(),
block.statements.position(),
);
}
state.set_dirty();
@ -581,14 +595,14 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
}
} else {
// Multiple ranges - clear the table and just keep the right ranges
if !table.is_empty() {
if !cases.is_empty() {
state.set_dirty();
table.clear();
cases.clear();
}
let old_ranges_len = ranges.len();
ranges.retain(|&mut (start, end, inclusive, _, _)| {
ranges.retain(|&mut (start, end, inclusive, _)| {
(!inclusive && (start..end).contains(&value))
|| (inclusive && (start..=end).contains(&value))
});
@ -597,16 +611,16 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
state.set_dirty();
}
for (_, _, _, condition, stmt_block) in ranges.iter_mut() {
let statements = mem::take(&mut **stmt_block);
**stmt_block =
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 c) = mem::take(condition) {
optimize_expr(&mut c, state, false);
match c {
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(),
_ => *condition = Some(c),
_ => block.condition = Some(condition),
}
}
}
@ -616,35 +630,41 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
// Promote the default case
state.set_dirty();
let def_stmt = optimize_stmt_block(mem::take(&mut *x.1), state, true, true, false);
*stmt = Stmt::Block(def_stmt.into_boxed_slice(), x.1.position().or_else(*pos));
let def_stmt =
optimize_stmt_block(mem::take(&mut x.def_case), state, true, true, false);
*stmt = Stmt::Block(
def_stmt.into_boxed_slice(),
x.def_case.position().or_else(*pos),
);
}
// switch
Stmt::Switch(match_expr, x, _) => {
optimize_expr(match_expr, state, false);
x.0.values_mut().for_each(|block| {
let statements = mem::take(&mut *block.1);
*block.1 = optimize_stmt_block(statements, state, preserve_result, true, false);
x.cases.values_mut().for_each(|block| {
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.0) {
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.0 = Some(condition),
_ => block.condition = Some(condition),
}
}
});
// Remove false cases
while let Some((&key, _)) = x.0.iter().find(|(_, block)| match block.0 {
while let Some((&key, _)) = x.cases.iter().find(|(_, block)| match block.condition {
Some(Expr::BoolConstant(false, _)) => true,
_ => false,
}) {
state.set_dirty();
x.0.remove(&key);
x.cases.remove(&key);
}
*x.1 = optimize_stmt_block(mem::take(&mut *x.1), state, preserve_result, true, false);
let def_block = mem::take(&mut *x.def_case);
*x.def_case = optimize_stmt_block(def_block, state, preserve_result, true, false);
}
// while false { block } -> Noop
@ -727,19 +747,21 @@ fn optimize_stmt(stmt: &mut Stmt, state: &mut OptimizerState, preserve_result: b
}
}
// try { pure try_block } catch ( var ) { catch_block } -> try_block
Stmt::TryCatch(x, _) if x.0.iter().all(Stmt::is_pure) => {
Stmt::TryCatch(x, _) if x.try_block.iter().all(Stmt::is_pure) => {
// If try block is pure, there will never be any exceptions
state.set_dirty();
*stmt = Stmt::Block(
optimize_stmt_block(mem::take(&mut *x.0), state, false, true, false)
optimize_stmt_block(mem::take(&mut *x.try_block), state, false, true, false)
.into_boxed_slice(),
x.0.position(),
x.try_block.position(),
);
}
// try { try_block } catch ( var ) { catch_block }
Stmt::TryCatch(x, _) => {
*x.0 = optimize_stmt_block(mem::take(&mut *x.0), state, false, true, false);
*x.2 = optimize_stmt_block(mem::take(&mut *x.2), state, false, true, false);
*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);
}
// func(...)
Stmt::Expr(expr @ Expr::FnCall(_, _)) => {
@ -800,8 +822,8 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, chaining: bool) {
#[cfg(not(feature = "no_object"))]
Expr::Dot(x,_, _) if !_chaining => match (&mut x.lhs, &mut x.rhs) {
// map.string
(Expr::Map(m, pos), Expr::Property(p)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
let prop = p.2.0.as_str();
(Expr::Map(m, pos), Expr::Property(p, _)) if m.0.iter().all(|(_, x)| x.is_pure()) => {
let prop = p.2.as_str();
// Map literal where everything is pure - promote the indexed item.
// All other items can be thrown away.
state.set_dirty();

129
src/parser.rs
View File

@ -3,8 +3,8 @@
use crate::api::custom_syntax::{markers::*, CustomSyntax};
use crate::api::options::LanguageOptions;
use crate::ast::{
BinaryExpr, CustomExpr, Expr, FnCallExpr, FnCallHashes, Ident, OpAssignment, ScriptFnDef, Stmt,
StmtBlock, AST_OPTION_FLAGS::*,
BinaryExpr, ConditionalStmtBlock, CustomExpr, Expr, FnCallExpr, FnCallHashes, Ident,
OpAssignment, ScriptFnDef, Stmt, StmtBlock, SwitchCases, TryCatchBlock, AST_OPTION_FLAGS::*,
};
use crate::engine::{Precedence, KEYWORD_THIS, OP_CONTAINS};
use crate::func::hashing::get_hasher;
@ -273,11 +273,14 @@ impl Expr {
let setter = state.get_identifier(crate::engine::FN_SET, &ident);
let hash_set = calc_fn_hash(&setter, 2);
Self::Property(Box::new((
Self::Property(
Box::new((
(getter, hash_get),
(setter, hash_set),
(state.get_interned_string("", &ident), pos),
)))
state.get_interned_string("", &ident),
)),
pos,
)
}
_ => self,
}
@ -985,8 +988,8 @@ fn parse_switch(
}
}
let mut table = BTreeMap::<u64, Box<(Option<Expr>, StmtBlock)>>::new();
let mut ranges = StaticVec::<(INT, INT, bool, Option<Expr>, StmtBlock)>::new();
let mut cases = BTreeMap::<u64, Box<ConditionalStmtBlock>>::new();
let mut ranges = StaticVec::<(INT, INT, bool, ConditionalStmtBlock)>::new();
let mut def_pos = Position::NONE;
let mut def_stmt = None;
@ -1050,7 +1053,7 @@ fn parse_switch(
value.hash(hasher);
let hash = hasher.finish();
if table.contains_key(&hash) {
if cases.contains_key(&hash) {
return Err(PERR::DuplicatedSwitchCase.into_err(expr.position()));
}
(Some(hash), None)
@ -1092,18 +1095,20 @@ fn parse_switch(
value.hash(hasher);
let hash = hasher.finish();
table
.entry(hash)
.or_insert_with(|| (condition.clone(), stmt.into()).into());
cases.entry(hash).or_insert_with(|| {
let block: ConditionalStmtBlock = (condition, stmt).into();
block.into()
});
}
// Other range
_ => ranges.push((range.0, range.1, range.2, condition, stmt.into())),
_ => ranges.push((range.0, range.1, range.2, (condition, stmt).into())),
}
}
None
}
(Some(hash), None) => {
table.insert(hash, (condition, stmt.into()).into());
let block: ConditionalStmtBlock = (condition, stmt).into();
cases.insert(hash, block.into());
None
}
(None, None) => Some(stmt.into()),
@ -1133,11 +1138,16 @@ fn parse_switch(
}
}
let def_stmt_block = def_stmt.unwrap_or_else(|| Stmt::Noop(Position::NONE).into());
let def_case = def_stmt.unwrap_or_else(|| Stmt::Noop(Position::NONE).into());
Ok(Stmt::Switch(
item,
(table, def_stmt_block, ranges).into(),
SwitchCases {
cases,
def_case,
ranges,
}
.into(),
settings.pos,
))
}
@ -1692,20 +1702,20 @@ fn make_assignment_stmt(
fn check_lvalue(expr: &Expr, parent_is_dot: bool) -> Option<Position> {
match expr {
Expr::Index(x, term, _) | Expr::Dot(x, term, _) if parent_is_dot => match x.lhs {
Expr::Property(_) if !term => {
Expr::Property(_, _) if !term => {
check_lvalue(&x.rhs, matches!(expr, Expr::Dot(_, _, _)))
}
Expr::Property(_) => None,
Expr::Property(_, _) => None,
// Anything other than a property after dotting (e.g. a method call) is not an l-value
ref e => Some(e.position()),
},
Expr::Index(x, term, _) | Expr::Dot(x, term, _) => match x.lhs {
Expr::Property(_) => unreachable!("unexpected Expr::Property in indexing"),
Expr::Property(_, _) => unreachable!("unexpected Expr::Property in indexing"),
_ if !term => check_lvalue(&x.rhs, matches!(expr, Expr::Dot(_, _, _))),
_ => None,
},
Expr::Property(_) if parent_is_dot => None,
Expr::Property(_) => unreachable!("unexpected Expr::Property in indexing"),
Expr::Property(_, _) if parent_is_dot => None,
Expr::Property(_, _) => unreachable!("unexpected Expr::Property in indexing"),
e if parent_is_dot => Some(e.position()),
_ => None,
}
@ -1719,9 +1729,10 @@ fn make_assignment_stmt(
Err(PERR::AssignmentToConstant("".into()).into_err(lhs.position()))
}
// var (non-indexed) = rhs
Expr::Variable(None, _, ref x) if x.0.is_none() => {
Ok(Stmt::Assignment((lhs, op_info, rhs).into(), op_pos))
}
Expr::Variable(None, _, ref x) if x.0.is_none() => Ok(Stmt::Assignment(
(op_info, (lhs, rhs).into()).into(),
op_pos,
)),
// var (indexed) = rhs
Expr::Variable(i, var_pos, ref x) => {
let (index, _, name) = x.as_ref();
@ -1730,7 +1741,10 @@ fn make_assignment_stmt(
|n| n.get() as usize,
);
match state.stack[state.stack.len() - index].1 {
AccessMode::ReadWrite => Ok(Stmt::Assignment((lhs, op_info, rhs).into(), op_pos)),
AccessMode::ReadWrite => Ok(Stmt::Assignment(
(op_info, (lhs, rhs).into()).into(),
op_pos,
)),
// Constant values cannot be assigned to
AccessMode::ReadOnly => {
Err(PERR::AssignmentToConstant(name.to_string()).into_err(var_pos))
@ -1749,9 +1763,10 @@ fn make_assignment_stmt(
None => {
match x.lhs {
// var[???] = rhs, var.??? = rhs
Expr::Variable(_, _, _) => {
Ok(Stmt::Assignment((lhs, op_info, rhs).into(), op_pos))
}
Expr::Variable(_, _, _) => Ok(Stmt::Assignment(
(op_info, (lhs, rhs).into()).into(),
op_pos,
)),
// expr[???] = rhs, expr.??? = rhs
ref expr => {
Err(PERR::AssignmentToInvalidLHS("".to_string())
@ -1830,7 +1845,7 @@ fn make_dot_expr(
Err(PERR::PropertyExpected.into_err(x.1.expect("`Some`").0[0].pos))
}
// lhs.prop
(lhs, prop @ Expr::Property(_)) => Ok(Expr::Dot(
(lhs, prop @ Expr::Property(_, _)) => Ok(Expr::Dot(
BinaryExpr { lhs, rhs: prop }.into(),
false,
op_pos,
@ -1844,7 +1859,7 @@ fn make_dot_expr(
};
match x.lhs {
Expr::Variable(_, _, _) | Expr::Property(_) => {
Expr::Variable(_, _, _) | Expr::Property(_, _) => {
let new_lhs = BinaryExpr {
lhs: x.lhs.into_property(state),
rhs: x.rhs,
@ -2603,48 +2618,27 @@ fn parse_export(
_ => (),
}
let mut exports = Vec::<(Ident, Ident)>::with_capacity(4);
loop {
let (id, id_pos) = parse_var_name(input)?;
let (rename, rename_pos) = if match_token(input, Token::As).0 {
let (alias, alias_pos) = if match_token(input, Token::As).0 {
let (name, pos) = parse_var_name(input)?;
if exports.iter().any(|(_, alias)| alias.name == name.as_ref()) {
return Err(PERR::DuplicatedVariable(name.to_string()).into_err(pos));
}
(Some(name), pos)
} else {
(None, Position::NONE)
};
exports.push((
let export = (
Ident {
name: state.get_identifier("", id),
pos: id_pos,
},
Ident {
name: state.get_identifier("", rename.as_ref().map_or("", <_>::as_ref)),
pos: rename_pos,
name: state.get_identifier("", alias.as_ref().map_or("", <_>::as_ref)),
pos: alias_pos,
},
));
);
match input.peek().expect(NEVER_ENDS) {
(Token::Comma, _) => {
eat_token(input, Token::Comma);
}
(Token::Identifier(_), pos) => {
return Err(PERR::MissingToken(
Token::Comma.into(),
"to separate the list of exports".into(),
)
.into_err(*pos))
}
_ => break,
}
}
Ok(Stmt::Export(exports.into_boxed_slice(), settings.pos))
Ok(Stmt::Export(export.into(), settings.pos))
}
/// Parse a statement block.
@ -2996,10 +2990,10 @@ fn parse_try_catch(
let mut settings = settings;
settings.pos = eat_token(input, Token::Try);
// try { body }
let body = parse_block(input, state, lib, settings.level_up())?;
// try { try_block }
let try_block = parse_block(input, state, lib, settings.level_up())?;
// try { body } catch
// try { try_block } catch
let (matched, catch_pos) = match_token(input, Token::Catch);
if !matched {
@ -3009,8 +3003,8 @@ fn parse_try_catch(
);
}
// try { body } catch (
let err_var = if match_token(input, Token::LeftParen).0 {
// try { try_block } catch (
let catch_var = if match_token(input, Token::LeftParen).0 {
let (name, pos) = parse_var_name(input)?;
let (matched, err_pos) = match_token(input, Token::RightParen);
@ -3029,16 +3023,21 @@ fn parse_try_catch(
None
};
// try { body } catch ( var ) { catch_block }
let catch_body = parse_block(input, state, lib, settings.level_up())?;
// try { try_block } catch ( var ) { catch_block }
let catch_block = parse_block(input, state, lib, settings.level_up())?;
if err_var.is_some() {
if catch_var.is_some() {
// Remove the error variable from the stack
state.stack.pop().unwrap();
}
Ok(Stmt::TryCatch(
(body.into(), err_var, catch_body.into()).into(),
TryCatchBlock {
try_block: try_block.into(),
catch_var,
catch_block: catch_block.into(),
}
.into(),
settings.pos,
))
}

9
tests/modules.rs
View File

@ -317,11 +317,10 @@ fn test_module_from_ast() -> Result<(), Box<EvalAltResult>> {
foo = calc(foo);
hello = `hello, ${foo} worlds!`;
export
x as abc,
x as xxx,
foo,
hello;
export x as abc;
export x as xxx;
export foo;
export hello;
"#,
)?;