diff --git a/src/engine.rs b/src/engine.rs index 3efc0067..110b29ee 100644 --- a/src/engine.rs +++ b/src/engine.rs @@ -857,78 +857,94 @@ impl Engine { if is_index { match rhs { - // xxx[idx].dot_rhs... - Expr::Dot(idx, idx_rhs, pos) | - // xxx[idx][dot_rhs]... - Expr::Index(idx, idx_rhs, pos) => { - let is_index = matches!(rhs, Expr::Index(_,_,_)); + // xxx[idx].dot_rhs... | xxx[idx][dot_rhs]... + Expr::Dot(x) | Expr::Index(x) => { + let is_index = matches!(rhs, Expr::Index(_)); - let indexed_val = self.get_indexed_mut(state, obj, idx_val, idx.position(), op_pos, false)?; + let indexed_val = + self.get_indexed_mut(state, obj, idx_val, x.0.position(), op_pos, false)?; self.eval_dot_index_chain_helper( - state, indexed_val, idx_rhs.as_ref(), idx_values, is_index, *pos, level, new_val + state, + indexed_val, + &x.1, + idx_values, + is_index, + x.2, + level, + new_val, ) } // xxx[rhs] = new_val _ if new_val.is_some() => { - let mut indexed_val = self.get_indexed_mut(state, obj, idx_val, rhs.position(), op_pos, true)?; + let mut indexed_val = + self.get_indexed_mut(state, obj, idx_val, rhs.position(), op_pos, true)?; indexed_val.set_value(new_val.unwrap(), rhs.position())?; Ok((Default::default(), true)) } // xxx[rhs] _ => self .get_indexed_mut(state, obj, idx_val, rhs.position(), op_pos, false) - .map(|v| (v.clone_into_dynamic(), false)) + .map(|v| (v.clone_into_dynamic(), false)), } } else { match rhs { // xxx.fn_name(arg_expr_list) - Expr::FnCall(fn_name, None, hash, _, def_val, pos) => { + Expr::FnCall(x) if x.1.is_none() => { let mut args: Vec<_> = once(obj) - .chain(idx_val.downcast_mut::>().unwrap().iter_mut()) + .chain( + idx_val + .downcast_mut::>() + .unwrap() + .iter_mut(), + ) .collect(); - let def_val = def_val.as_deref(); + let def_val = x.4.as_deref(); // A function call is assumed to have side effects, so the value is changed // TODO - Remove assumption of side effects by checking whether the first parameter is &mut - self.exec_fn_call(state, fn_name, *hash, &mut args, def_val, *pos, 0).map(|v| (v, true)) + self.exec_fn_call(state, &x.0, x.2, &mut args, def_val, x.5, 0) + .map(|v| (v, true)) } // xxx.module::fn_name(...) - syntax error - Expr::FnCall(_, _, _, _, _, _) => unreachable!(), + Expr::FnCall(_) => unreachable!(), // {xxx:map}.id = ??? #[cfg(not(feature = "no_object"))] - Expr::Property(id, pos) if obj.is::() && new_val.is_some() => { + Expr::Property(x) if obj.is::() && new_val.is_some() => { + let index = x.0.clone().into(); let mut indexed_val = - self.get_indexed_mut(state, obj, id.to_string().into(), *pos, op_pos, true)?; + self.get_indexed_mut(state, obj, index, x.1, op_pos, true)?; indexed_val.set_value(new_val.unwrap(), rhs.position())?; Ok((Default::default(), true)) } // {xxx:map}.id #[cfg(not(feature = "no_object"))] - Expr::Property(id, pos) if obj.is::() => { + Expr::Property(x) if obj.is::() => { + let index = x.0.clone().into(); let indexed_val = - self.get_indexed_mut(state, obj, id.to_string().into(), *pos, op_pos, false)?; + self.get_indexed_mut(state, obj, index, x.1, op_pos, false)?; Ok((indexed_val.clone_into_dynamic(), false)) } // xxx.id = ??? a - Expr::Property(id, pos) if new_val.is_some() => { - let fn_name = make_setter(id); + Expr::Property(x) if new_val.is_some() => { + let fn_name = make_setter(&x.0); let mut args = [obj, new_val.as_mut().unwrap()]; - self.exec_fn_call(state, &fn_name, 0, &mut args, None, *pos, 0).map(|v| (v, true)) + self.exec_fn_call(state, &fn_name, 0, &mut args, None, x.1, 0) + .map(|v| (v, true)) } // xxx.id - Expr::Property(id, pos) => { - let fn_name = make_getter(id); + Expr::Property(x) => { + let fn_name = make_getter(&x.0); let mut args = [obj]; - self.exec_fn_call(state, &fn_name, 0, &mut args, None, *pos, 0).map(|v| (v, false)) + self.exec_fn_call(state, &fn_name, 0, &mut args, None, x.1, 0) + .map(|v| (v, false)) } #[cfg(not(feature = "no_object"))] - // {xxx:map}.idx_lhs[idx_expr] - Expr::Index(dot_lhs, dot_rhs, pos) | - // {xxx:map}.dot_lhs.rhs - Expr::Dot(dot_lhs, dot_rhs, pos) if obj.is::() => { - let is_index = matches!(rhs, Expr::Index(_,_,_)); + // {xxx:map}.idx_lhs[idx_expr] | {xxx:map}.dot_lhs.rhs + Expr::Index(x) | Expr::Dot(x) if obj.is::() => { + let is_index = matches!(rhs, Expr::Index(_)); - let indexed_val = if let Expr::Property(id, pos) = dot_lhs.as_ref() { - self.get_indexed_mut(state, obj, id.to_string().into(), *pos, op_pos, false)? + let indexed_val = if let Expr::Property(p) = &x.0 { + let index = p.0.clone().into(); + self.get_indexed_mut(state, obj, index, x.2, op_pos, false)? } else { // Syntax error return Err(Box::new(EvalAltResult::ErrorDotExpr( @@ -937,19 +953,24 @@ impl Engine { ))); }; self.eval_dot_index_chain_helper( - state, indexed_val, dot_rhs, idx_values, is_index, *pos, level, new_val + state, + indexed_val, + &x.1, + idx_values, + is_index, + x.2, + level, + new_val, ) } - // xxx.idx_lhs[idx_expr] - Expr::Index(dot_lhs, dot_rhs, pos) | - // xxx.dot_lhs.rhs - Expr::Dot(dot_lhs, dot_rhs, pos) => { - let is_index = matches!(rhs, Expr::Index(_,_,_)); + // xxx.idx_lhs[idx_expr] | xxx.dot_lhs.rhs + Expr::Index(x) | Expr::Dot(x) => { + let is_index = matches!(rhs, Expr::Index(_)); let mut args = [obj, &mut Default::default()]; - let indexed_val = &mut (if let Expr::Property(id, pos) = dot_lhs.as_ref() { - let fn_name = make_getter(id); - self.exec_fn_call(state, &fn_name, 0, &mut args[..1], None, *pos, 0)? + let indexed_val = &mut (if let Expr::Property(p) = &x.0 { + let fn_name = make_getter(&p.0); + self.exec_fn_call(state, &fn_name, 0, &mut args[..1], None, x.2, 0)? } else { // Syntax error return Err(Box::new(EvalAltResult::ErrorDotExpr( @@ -958,20 +979,28 @@ impl Engine { ))); }); let (result, may_be_changed) = self.eval_dot_index_chain_helper( - state, indexed_val.into(), dot_rhs, idx_values, is_index, *pos, level, new_val + state, + indexed_val.into(), + &x.1, + idx_values, + is_index, + x.2, + level, + new_val, )?; // Feed the value back via a setter just in case it has been updated if may_be_changed { - if let Expr::Property(id, pos) = dot_lhs.as_ref() { - let fn_name = make_setter(id); + if let Expr::Property(p) = &x.0 { + let fn_name = make_setter(&p.0); // Re-use args because the first &mut parameter will not be consumed args[1] = indexed_val; - self.exec_fn_call(state, &fn_name, 0, &mut args, None, *pos, 0).or_else(|err| match *err { - // If there is no setter, no need to feed it back because the property is read-only - EvalAltResult::ErrorDotExpr(_,_) => Ok(Default::default()), - err => Err(Box::new(err)) - })?; + self.exec_fn_call(state, &fn_name, 0, &mut args, None, x.2, 0) + .or_else(|err| match *err { + // If there is no setter, no need to feed it back because the property is read-only + EvalAltResult::ErrorDotExpr(_, _) => Ok(Default::default()), + err => Err(Box::new(err)), + })?; } } @@ -1004,18 +1033,18 @@ impl Engine { match dot_lhs { // id.??? or id[???] - Expr::Variable(id, modules, hash, index, pos) => { - let index = if state.always_search { None } else { *index }; + Expr::Variable(x) => { + let index = if state.always_search { None } else { x.3 }; let (target, typ) = - search_scope(scope, id, modules.as_ref().map(|m| (m, *hash)), index, *pos)?; + search_scope(scope, &x.0, x.1.as_ref().map(|m| (m, x.2)), index, x.4)?; // Constants cannot be modified match typ { ScopeEntryType::Module => unreachable!(), ScopeEntryType::Constant if new_val.is_some() => { return Err(Box::new(EvalAltResult::ErrorAssignmentToConstant( - id.to_string(), - *pos, + x.0.clone(), + x.4, ))); } ScopeEntryType::Constant | ScopeEntryType::Normal => (), @@ -1060,26 +1089,26 @@ impl Engine { level: usize, ) -> Result<(), Box> { match expr { - Expr::FnCall(_, None, _, arg_exprs, _, _) => { + Expr::FnCall(x) if x.1.is_none() => { let mut arg_values = StaticVec::::new(); - for arg_expr in arg_exprs.iter() { + for arg_expr in x.3.iter() { arg_values.push(self.eval_expr(scope, state, arg_expr, level)?); } idx_values.push(Dynamic::from(arg_values)); } - Expr::FnCall(_, _, _, _, _, _) => unreachable!(), - Expr::Property(_, _) => idx_values.push(()), // Store a placeholder - no need to copy the property name - Expr::Index(lhs, rhs, _) | Expr::Dot(lhs, rhs, _) => { + Expr::FnCall(_) => unreachable!(), + Expr::Property(_) => idx_values.push(()), // Store a placeholder - no need to copy the property name + Expr::Index(x) | Expr::Dot(x) => { // Evaluate in left-to-right order - let lhs_val = match lhs.as_ref() { - Expr::Property(_, _) => Default::default(), // Store a placeholder in case of a property - _ => self.eval_expr(scope, state, lhs, level)?, + let lhs_val = match x.0 { + Expr::Property(_) => Default::default(), // Store a placeholder in case of a property + _ => self.eval_expr(scope, state, &x.0, level)?, }; // Push in reverse order - self.eval_indexed_chain(scope, state, rhs, idx_values, size, level)?; + self.eval_indexed_chain(scope, state, &x.1, idx_values, size, level)?; idx_values.push(lhs_val); } @@ -1255,35 +1284,36 @@ impl Engine { level: usize, ) -> Result> { match expr { - Expr::IntegerConstant(i, _) => Ok((*i).into()), + Expr::IntegerConstant(x) => Ok(x.0.into()), #[cfg(not(feature = "no_float"))] - Expr::FloatConstant(f, _) => Ok((*f).into()), - Expr::StringConstant(s, _) => Ok(s.to_string().into()), - Expr::CharConstant(c, _) => Ok((*c).into()), - Expr::Variable(id, modules, hash, index, pos) => { - let index = if state.always_search { None } else { *index }; - let mod_and_hash = modules.as_ref().map(|m| (m, *hash)); - let (val, _) = search_scope(scope, id, mod_and_hash, index, *pos)?; + Expr::FloatConstant(x) => Ok(x.0.into()), + Expr::StringConstant(x) => Ok(x.0.to_string().into()), + Expr::CharConstant(x) => Ok(x.0.into()), + Expr::Variable(x) => { + let index = if state.always_search { None } else { x.3 }; + let mod_and_hash = x.1.as_ref().map(|m| (m, x.2)); + let (val, _) = search_scope(scope, &x.0, mod_and_hash, index, x.4)?; Ok(val.clone()) } - Expr::Property(_, _) => unreachable!(), + Expr::Property(_) => unreachable!(), // Statement block - Expr::Stmt(stmt, _) => self.eval_stmt(scope, state, stmt, level), + Expr::Stmt(stmt) => self.eval_stmt(scope, state, &stmt.0, level), // lhs = rhs - Expr::Assignment(lhs, rhs, op_pos) => { - let rhs_val = self.eval_expr(scope, state, rhs, level)?; + Expr::Assignment(x) => { + let op_pos = x.2; + let rhs_val = self.eval_expr(scope, state, &x.1, level)?; - match lhs.as_ref() { + match &x.0 { // name = rhs - Expr::Variable(id, modules, hash, index, pos) => { - let index = if state.always_search { None } else { *index }; - let mod_and_hash = modules.as_ref().map(|m| (m, *hash)); - let (value_ptr, typ) = search_scope(scope, id, mod_and_hash, index, *pos)?; + Expr::Variable(x) => { + let index = if state.always_search { None } else { x.3 }; + let mod_and_hash = x.1.as_ref().map(|m| (m, x.2)); + let (value_ptr, typ) = search_scope(scope, &x.0, mod_and_hash, index, x.4)?; match typ { ScopeEntryType::Constant => Err(Box::new( - EvalAltResult::ErrorAssignmentToConstant(id.to_string(), *pos), + EvalAltResult::ErrorAssignmentToConstant(x.0.clone(), x.4), )), ScopeEntryType::Normal => { *value_ptr = rhs_val; @@ -1295,58 +1325,56 @@ impl Engine { } // idx_lhs[idx_expr] = rhs #[cfg(not(feature = "no_index"))] - Expr::Index(idx_lhs, idx_expr, op_pos) => { + Expr::Index(x) => { let new_val = Some(rhs_val); self.eval_dot_index_chain( - scope, state, idx_lhs, idx_expr, true, *op_pos, level, new_val, + scope, state, &x.0, &x.1, true, x.2, level, new_val, ) } // dot_lhs.dot_rhs = rhs #[cfg(not(feature = "no_object"))] - Expr::Dot(dot_lhs, dot_rhs, _) => { + Expr::Dot(x) => { let new_val = Some(rhs_val); self.eval_dot_index_chain( - scope, state, dot_lhs, dot_rhs, false, *op_pos, level, new_val, + scope, state, &x.0, &x.1, false, op_pos, level, new_val, ) } // Error assignment to constant expr if expr.is_constant() => { Err(Box::new(EvalAltResult::ErrorAssignmentToConstant( expr.get_constant_str(), - lhs.position(), + expr.position(), ))) } // Syntax error - _ => Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS( - lhs.position(), + expr => Err(Box::new(EvalAltResult::ErrorAssignmentToUnknownLHS( + expr.position(), ))), } } // lhs[idx_expr] #[cfg(not(feature = "no_index"))] - Expr::Index(lhs, idx_expr, op_pos) => { - self.eval_dot_index_chain(scope, state, lhs, idx_expr, true, *op_pos, level, None) + Expr::Index(x) => { + self.eval_dot_index_chain(scope, state, &x.0, &x.1, true, x.2, level, None) } // lhs.dot_rhs #[cfg(not(feature = "no_object"))] - Expr::Dot(lhs, dot_rhs, op_pos) => { - self.eval_dot_index_chain(scope, state, lhs, dot_rhs, false, *op_pos, level, None) + Expr::Dot(x) => { + self.eval_dot_index_chain(scope, state, &x.0, &x.1, false, x.2, level, None) } #[cfg(not(feature = "no_index"))] - Expr::Array(contents, _) => Ok(Dynamic(Union::Array(Box::new( - contents - .iter() + Expr::Array(x) => Ok(Dynamic(Union::Array(Box::new( + x.0.iter() .map(|item| self.eval_expr(scope, state, item, level)) .collect::, _>>()?, )))), #[cfg(not(feature = "no_object"))] - Expr::Map(contents, _) => Ok(Dynamic(Union::Map(Box::new( - contents - .iter() + Expr::Map(x) => Ok(Dynamic(Union::Map(Box::new( + x.0.iter() .map(|(key, expr, _)| { self.eval_expr(scope, state, expr, level) .map(|val| (key.clone(), val)) @@ -1355,27 +1383,26 @@ impl Engine { )))), // Normal function call - Expr::FnCall(fn_name, None, hash, arg_exprs, def_val, pos) => { - let mut arg_values = arg_exprs - .iter() - .map(|expr| self.eval_expr(scope, state, expr, level)) - .collect::, _>>()?; + Expr::FnCall(x) if x.1.is_none() => { + let mut arg_values = + x.3.iter() + .map(|expr| self.eval_expr(scope, state, expr, level)) + .collect::, _>>()?; let mut args: Vec<_> = arg_values.iter_mut().collect(); let hash_fn_spec = calc_fn_hash(empty(), KEYWORD_EVAL, once(TypeId::of::())); - if fn_name.as_ref() == KEYWORD_EVAL + if x.0 == KEYWORD_EVAL && args.len() == 1 - && !self.has_override(state, hash_fn_spec, *hash) + && !self.has_override(state, hash_fn_spec, x.2) { // eval - only in function call style let prev_len = scope.len(); // Evaluate the text string as a script - let result = - self.eval_script_expr(scope, state, args[0], arg_exprs[0].position()); + let result = self.eval_script_expr(scope, state, args[0], x.3[0].position()); if scope.len() != prev_len { // IMPORTANT! If the eval defines new variables in the current scope, @@ -1386,20 +1413,20 @@ impl Engine { result } else { // Normal function call - except for eval (handled above) - let def_value = def_val.as_deref(); - self.exec_fn_call(state, fn_name, *hash, &mut args, def_value, *pos, level) + let def_value = x.4.as_deref(); + self.exec_fn_call(state, &x.0, x.2, &mut args, def_value, x.5, level) } } // Module-qualified function call #[cfg(not(feature = "no_module"))] - Expr::FnCall(fn_name, Some(modules), hash1, arg_exprs, def_val, pos) => { - let modules = modules.as_ref(); + Expr::FnCall(x) if x.1.is_some() => { + let modules = x.1.as_ref().unwrap(); - let mut arg_values = arg_exprs - .iter() - .map(|expr| self.eval_expr(scope, state, expr, level)) - .collect::, _>>()?; + let mut arg_values = + x.3.iter() + .map(|expr| self.eval_expr(scope, state, expr, level)) + .collect::, _>>()?; let mut args: Vec<_> = arg_values.iter_mut().collect(); @@ -1418,8 +1445,8 @@ impl Engine { }; // First search in script-defined functions (can override built-in) - if let Some(fn_def) = module.get_qualified_scripted_fn(*hash1) { - self.call_script_fn(None, state, fn_def, &mut args, *pos, level) + if let Some(fn_def) = module.get_qualified_scripted_fn(x.2) { + self.call_script_fn(None, state, fn_def, &mut args, x.5, level) } else { // Then search in Rust functions @@ -1430,47 +1457,45 @@ impl Engine { // the actual list of parameter `TypeId`'.s let hash2 = calc_fn_hash(empty(), "", args.iter().map(|a| a.type_id())); // 3) The final hash is the XOR of the two hashes. - let hash = *hash1 ^ hash2; + let hash = x.2 ^ hash2; - match module.get_qualified_fn(fn_name, hash, *pos) { - Ok(func) => func(&mut args, *pos), - Err(_) if def_val.is_some() => Ok(def_val.as_deref().unwrap().clone()), + match module.get_qualified_fn(&x.0, hash, x.5) { + Ok(func) => func(&mut args, x.5), + Err(_) if x.4.is_some() => Ok(x.4.as_deref().unwrap().clone()), Err(err) => Err(err), } } } - Expr::In(lhs, rhs, _) => { - self.eval_in_expr(scope, state, lhs.as_ref(), rhs.as_ref(), level) - } + Expr::In(x) => self.eval_in_expr(scope, state, &x.0, &x.1, level), - Expr::And(lhs, rhs, _) => Ok((self - .eval_expr(scope, state, lhs.as_ref(), level)? + Expr::And(x) => Ok((self + .eval_expr(scope, state, &x.0, level)? .as_bool() .map_err(|_| { - EvalAltResult::ErrorBooleanArgMismatch("AND".into(), lhs.position()) + EvalAltResult::ErrorBooleanArgMismatch("AND".into(), x.0.position()) })? && // Short-circuit using && self - .eval_expr(scope, state, rhs.as_ref(), level)? + .eval_expr(scope, state, &x.1, level)? .as_bool() .map_err(|_| { - EvalAltResult::ErrorBooleanArgMismatch("AND".into(), rhs.position()) + EvalAltResult::ErrorBooleanArgMismatch("AND".into(), x.1.position()) })?) .into()), - Expr::Or(lhs, rhs, _) => Ok((self - .eval_expr(scope, state, lhs.as_ref(), level)? + Expr::Or(x) => Ok((self + .eval_expr(scope, state, &x.0, level)? .as_bool() .map_err(|_| { - EvalAltResult::ErrorBooleanArgMismatch("OR".into(), lhs.position()) + EvalAltResult::ErrorBooleanArgMismatch("OR".into(), x.0.position()) })? || // Short-circuit using || self - .eval_expr(scope, state, rhs.as_ref(), level)? + .eval_expr(scope, state, &x.1, level)? .as_bool() .map_err(|_| { - EvalAltResult::ErrorBooleanArgMismatch("OR".into(), rhs.position()) + EvalAltResult::ErrorBooleanArgMismatch("OR".into(), x.1.position()) })?) .into()), @@ -1498,7 +1523,7 @@ impl Engine { Stmt::Expr(expr) => { let result = self.eval_expr(scope, state, expr, level)?; - Ok(if let Expr::Assignment(_, _, _) = *expr.as_ref() { + Ok(if let Expr::Assignment(_) = *expr.as_ref() { // If it is an assignment, erase the result at the root Default::default() } else { @@ -1507,10 +1532,10 @@ impl Engine { } // Block scope - Stmt::Block(block, _) => { + Stmt::Block(x) => { let prev_len = scope.len(); - let result = block.iter().try_fold(Default::default(), |_, stmt| { + let result = x.0.iter().try_fold(Default::default(), |_, stmt| { self.eval_stmt(scope, state, stmt, level) }); @@ -1524,24 +1549,24 @@ impl Engine { } // If-else statement - Stmt::IfThenElse(guard, if_body, else_body) => self - .eval_expr(scope, state, guard, level)? + Stmt::IfThenElse(x) => self + .eval_expr(scope, state, &x.0, level)? .as_bool() - .map_err(|_| Box::new(EvalAltResult::ErrorLogicGuard(guard.position()))) + .map_err(|_| Box::new(EvalAltResult::ErrorLogicGuard(x.0.position()))) .and_then(|guard_val| { if guard_val { - self.eval_stmt(scope, state, if_body, level) - } else if let Some(stmt) = else_body { - self.eval_stmt(scope, state, stmt.as_ref(), level) + self.eval_stmt(scope, state, &x.1, level) + } else if let Some(stmt) = &x.2 { + self.eval_stmt(scope, state, stmt, level) } else { Ok(Default::default()) } }), // While loop - Stmt::While(guard, body) => loop { - match self.eval_expr(scope, state, guard, level)?.as_bool() { - Ok(true) => match self.eval_stmt(scope, state, body, level) { + Stmt::While(x) => loop { + match self.eval_expr(scope, state, &x.0, level)?.as_bool() { + Ok(true) => match self.eval_stmt(scope, state, &x.1, level) { Ok(_) => (), Err(err) => match *err { EvalAltResult::ErrorLoopBreak(false, _) => (), @@ -1550,9 +1575,7 @@ impl Engine { }, }, Ok(false) => return Ok(Default::default()), - Err(_) => { - return Err(Box::new(EvalAltResult::ErrorLogicGuard(guard.position()))) - } + Err(_) => return Err(Box::new(EvalAltResult::ErrorLogicGuard(x.0.position()))), } }, @@ -1569,9 +1592,9 @@ impl Engine { }, // For loop - Stmt::For(name, expr, body) => { - let arr = self.eval_expr(scope, state, expr, level)?; - let tid = arr.type_id(); + Stmt::For(x) => { + let iter_type = self.eval_expr(scope, state, &x.1, level)?; + let tid = iter_type.type_id(); if let Some(iter_fn) = self .base_package @@ -1579,14 +1602,14 @@ impl Engine { .or_else(|| self.packages.get_iterator(tid)) { // Add the loop variable - let var_name = name.as_ref().clone(); - scope.push(var_name, ()); + let name = x.0.clone(); + scope.push(name, ()); let index = scope.len() - 1; - for a in iter_fn(arr) { + for a in iter_fn(iter_type) { *scope.get_mut(index).0 = a; - match self.eval_stmt(scope, state, body, level) { + match self.eval_stmt(scope, state, &x.2, level) { Ok(_) => (), Err(err) => match *err { EvalAltResult::ErrorLoopBreak(false, _) => (), @@ -1599,7 +1622,7 @@ impl Engine { scope.rewind(scope.len() - 1); Ok(Default::default()) } else { - Err(Box::new(EvalAltResult::ErrorFor(expr.position()))) + Err(Box::new(EvalAltResult::ErrorFor(x.1.position()))) } } @@ -1609,67 +1632,74 @@ impl Engine { // Break statement Stmt::Break(pos) => Err(Box::new(EvalAltResult::ErrorLoopBreak(true, *pos))), - // Empty return - Stmt::ReturnWithVal(None, ReturnType::Return, pos) => { - Err(Box::new(EvalAltResult::Return(Default::default(), *pos))) - } - // Return value - Stmt::ReturnWithVal(Some(a), ReturnType::Return, pos) => Err(Box::new( - EvalAltResult::Return(self.eval_expr(scope, state, a, level)?, *pos), - )), - - // Empty throw - Stmt::ReturnWithVal(None, ReturnType::Exception, pos) => { - Err(Box::new(EvalAltResult::ErrorRuntime("".into(), *pos))) - } - - // Throw value - Stmt::ReturnWithVal(Some(a), ReturnType::Exception, pos) => { - let val = self.eval_expr(scope, state, a, level)?; - Err(Box::new(EvalAltResult::ErrorRuntime( - val.take_string().unwrap_or_else(|_| "".to_string()), - *pos, + Stmt::ReturnWithVal(x) if x.0.is_some() && x.1 == ReturnType::Return => { + Err(Box::new(EvalAltResult::Return( + self.eval_expr(scope, state, x.0.as_ref().unwrap(), level)?, + x.2, ))) } + // Empty return + Stmt::ReturnWithVal(x) if x.1 == ReturnType::Return => { + Err(Box::new(EvalAltResult::Return(Default::default(), x.2))) + } + + // Throw value + Stmt::ReturnWithVal(x) if x.0.is_some() && x.1 == ReturnType::Exception => { + let val = self.eval_expr(scope, state, x.0.as_ref().unwrap(), level)?; + Err(Box::new(EvalAltResult::ErrorRuntime( + val.take_string().unwrap_or_else(|_| "".to_string()), + x.2, + ))) + } + + // Empty throw + Stmt::ReturnWithVal(x) if x.1 == ReturnType::Exception => { + Err(Box::new(EvalAltResult::ErrorRuntime("".into(), x.2))) + } + + Stmt::ReturnWithVal(_) => unreachable!(), + // Let statement - Stmt::Let(name, Some(expr), _) => { - let val = self.eval_expr(scope, state, expr, level)?; + Stmt::Let(x) if x.1.is_some() => { + let val = self.eval_expr(scope, state, x.1.as_ref().unwrap(), level)?; // TODO - avoid copying variable name in inner block? - let var_name = name.as_ref().clone(); + let var_name = x.0.clone(); scope.push_dynamic_value(var_name, ScopeEntryType::Normal, val, false); Ok(Default::default()) } - Stmt::Let(name, None, _) => { + Stmt::Let(x) => { // TODO - avoid copying variable name in inner block? - let var_name = name.as_ref().clone(); + let var_name = x.0.clone(); scope.push(var_name, ()); Ok(Default::default()) } // Const statement - Stmt::Const(name, expr, _) if expr.is_constant() => { - let val = self.eval_expr(scope, state, expr, level)?; + Stmt::Const(x) if x.1.is_constant() => { + let val = self.eval_expr(scope, state, &x.1, level)?; // TODO - avoid copying variable name in inner block? - let var_name = name.as_ref().clone(); + let var_name = x.0.clone(); scope.push_dynamic_value(var_name, ScopeEntryType::Constant, val, true); Ok(Default::default()) } // Const expression not constant - Stmt::Const(_, _, _) => unreachable!(), + Stmt::Const(_) => unreachable!(), // Import statement - Stmt::Import(expr, name, _) => { + Stmt::Import(x) => { + let (expr, name, _) = x.as_ref(); + #[cfg(feature = "no_module")] unreachable!(); #[cfg(not(feature = "no_module"))] { if let Some(path) = self - .eval_expr(scope, state, expr, level)? + .eval_expr(scope, state, &expr, level)? .try_cast::() { if let Some(resolver) = self.module_resolver.as_ref() { @@ -1678,7 +1708,7 @@ impl Engine { resolver.resolve(self, Scope::new(), &path, expr.position())?; // TODO - avoid copying module name in inner block? - let mod_name = name.as_ref().clone(); + let mod_name = name.clone(); scope.push_module(mod_name, module); Ok(Default::default()) } else { @@ -1695,7 +1725,7 @@ impl Engine { // Export statement Stmt::Export(list) => { - for (id, id_pos, rename) in list { + for (id, id_pos, rename) in list.as_ref() { let mut found = false; // Mark scope variables as public diff --git a/src/optimize.rs b/src/optimize.rs index 8a1ad745..223949d6 100644 --- a/src/optimize.rs +++ b/src/optimize.rs @@ -131,63 +131,63 @@ fn call_fn( fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) -> Stmt { match stmt { // if expr { Noop } - Stmt::IfThenElse(expr, if_block, None) if matches!(*if_block, Stmt::Noop(_)) => { + Stmt::IfThenElse(x) if matches!(x.1, Stmt::Noop(_)) => { state.set_dirty(); - let pos = expr.position(); - let expr = optimize_expr(*expr, state); + let pos = x.0.position(); + let expr = optimize_expr(x.0, state); if preserve_result { // -> { expr, Noop } - Stmt::Block(vec![Stmt::Expr(Box::new(expr)), *if_block], pos) + Stmt::Block(Box::new((vec![Stmt::Expr(Box::new(expr)), x.1], pos))) } else { // -> expr Stmt::Expr(Box::new(expr)) } } // if expr { if_block } - Stmt::IfThenElse(expr, if_block, None) => match *expr { + Stmt::IfThenElse(x) if x.2.is_none() => match x.0 { // if false { if_block } -> Noop Expr::False(pos) => { state.set_dirty(); Stmt::Noop(pos) } // if true { if_block } -> if_block - Expr::True(_) => optimize_stmt(*if_block, state, true), + Expr::True(_) => optimize_stmt(x.1, state, true), // if expr { if_block } - expr => Stmt::IfThenElse( - Box::new(optimize_expr(expr, state)), - Box::new(optimize_stmt(*if_block, state, true)), + expr => Stmt::IfThenElse(Box::new(( + optimize_expr(expr, state), + optimize_stmt(x.1, state, true), None, - ), + ))), }, // if expr { if_block } else { else_block } - Stmt::IfThenElse(expr, if_block, Some(else_block)) => match *expr { + Stmt::IfThenElse(x) if x.2.is_some() => match x.0 { // if false { if_block } else { else_block } -> else_block - Expr::False(_) => optimize_stmt(*else_block, state, true), + Expr::False(_) => optimize_stmt(x.2.unwrap(), state, true), // if true { if_block } else { else_block } -> if_block - Expr::True(_) => optimize_stmt(*if_block, state, true), + Expr::True(_) => optimize_stmt(x.1, state, true), // if expr { if_block } else { else_block } - expr => Stmt::IfThenElse( - Box::new(optimize_expr(expr, state)), - Box::new(optimize_stmt(*if_block, state, true)), - match optimize_stmt(*else_block, state, true) { + expr => Stmt::IfThenElse(Box::new(( + optimize_expr(expr, state), + optimize_stmt(x.1, state, true), + match optimize_stmt(x.2.unwrap(), state, true) { Stmt::Noop(_) => None, // Noop -> no else block - stmt => Some(Box::new(stmt)), + stmt => Some(stmt), }, - ), + ))), }, // while expr { block } - Stmt::While(expr, block) => match *expr { + Stmt::While(x) => match x.0 { // while false { block } -> Noop Expr::False(pos) => { state.set_dirty(); Stmt::Noop(pos) } // while true { block } -> loop { block } - Expr::True(_) => Stmt::Loop(Box::new(optimize_stmt(*block, state, false))), + Expr::True(_) => Stmt::Loop(Box::new(optimize_stmt(x.1, state, false))), // while expr { block } - expr => match optimize_stmt(*block, state, false) { + expr => match optimize_stmt(x.1, state, false) { // while expr { break; } -> { expr; } Stmt::Break(pos) => { // Only a single break statement - turn into running the guard expression once @@ -196,10 +196,10 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - if preserve_result { statements.push(Stmt::Noop(pos)) } - Stmt::Block(statements, pos) + Stmt::Block(Box::new((statements, pos))) } // while expr { block } - stmt => Stmt::While(Box::new(optimize_expr(expr, state)), Box::new(stmt)), + stmt => Stmt::While(Box::new((optimize_expr(expr, state), stmt))), }, }, // loop { block } @@ -214,38 +214,41 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - stmt => Stmt::Loop(Box::new(stmt)), }, // for id in expr { block } - Stmt::For(id, expr, block) => Stmt::For( - id, - Box::new(optimize_expr(*expr, state)), - Box::new(optimize_stmt(*block, state, false)), - ), + Stmt::For(x) => Stmt::For(Box::new(( + x.0, + optimize_expr(x.1, state), + optimize_stmt(x.2, state, false), + ))), // let id = expr; - Stmt::Let(id, Some(expr), pos) => { - Stmt::Let(id, Some(Box::new(optimize_expr(*expr, state))), pos) - } + Stmt::Let(x) if x.1.is_some() => Stmt::Let(Box::new(( + x.0, + Some(optimize_expr(x.1.unwrap(), state)), + x.2, + ))), // let id; - Stmt::Let(_, None, _) => stmt, + stmt @ Stmt::Let(_) => stmt, // import expr as id; - Stmt::Import(expr, id, pos) => Stmt::Import(Box::new(optimize_expr(*expr, state)), id, pos), + Stmt::Import(x) => Stmt::Import(Box::new((optimize_expr(x.0, state), x.1, x.2))), // { block } - Stmt::Block(block, pos) => { - let orig_len = block.len(); // Original number of statements in the block, for change detection + Stmt::Block(x) => { + let orig_len = x.0.len(); // Original number of statements in the block, for change detection let orig_constants_len = state.constants.len(); // Original number of constants in the state, for restore later + let pos = x.1; // Optimize each statement in the block - let mut result: Vec<_> = block - .into_iter() - .map(|stmt| match stmt { - // Add constant into the state - Stmt::Const(name, value, pos) => { - state.push_constant(&name, *value); - state.set_dirty(); - Stmt::Noop(pos) // No need to keep constants - } - // Optimize the statement - _ => optimize_stmt(stmt, state, preserve_result), - }) - .collect(); + let mut result: Vec<_> = + x.0.into_iter() + .map(|stmt| match stmt { + // Add constant into the state + Stmt::Const(v) => { + state.push_constant(&v.0, v.1); + state.set_dirty(); + Stmt::Noop(v.2) // No need to keep constants + } + // Optimize the statement + _ => optimize_stmt(stmt, state, preserve_result), + }) + .collect(); // Remove all raw expression statements that are pure except for the very last statement let last_stmt = if preserve_result { result.pop() } else { None }; @@ -263,9 +266,9 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - while let Some(expr) = result.pop() { match expr { - Stmt::Let(_, None, _) => removed = true, - Stmt::Let(_, Some(val_expr), _) => removed = val_expr.is_pure(), - Stmt::Import(expr, _, _) => removed = expr.is_pure(), + Stmt::Let(x) if x.1.is_none() => removed = true, + Stmt::Let(x) if x.1.is_some() => removed = x.1.unwrap().is_pure(), + Stmt::Import(x) => removed = x.0.is_pure(), _ => { result.push(expr); break; @@ -297,7 +300,7 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - } match stmt { - Stmt::ReturnWithVal(_, _, _) | Stmt::Break(_) => { + Stmt::ReturnWithVal(_) | Stmt::Break(_) => { dead_code = true; } _ => (), @@ -321,21 +324,23 @@ fn optimize_stmt<'a>(stmt: Stmt, state: &mut State<'a>, preserve_result: bool) - Stmt::Noop(pos) } // Only one let/import statement - leave it alone - [Stmt::Let(_, _, _)] | [Stmt::Import(_, _, _)] => Stmt::Block(result, pos), + [Stmt::Let(_)] | [Stmt::Import(_)] => Stmt::Block(Box::new((result, pos))), // Only one statement - promote [_] => { state.set_dirty(); result.remove(0) } - _ => Stmt::Block(result, pos), + _ => Stmt::Block(Box::new((result, pos))), } } // expr; Stmt::Expr(expr) => Stmt::Expr(Box::new(optimize_expr(*expr, state))), // return expr; - Stmt::ReturnWithVal(Some(expr), is_return, pos) => { - Stmt::ReturnWithVal(Some(Box::new(optimize_expr(*expr, state))), is_return, pos) - } + Stmt::ReturnWithVal(x) if x.0.is_some() => Stmt::ReturnWithVal(Box::new(( + Some(optimize_expr(x.0.unwrap(), state)), + x.1, + x.2, + ))), // All other statements - skip stmt => stmt, } @@ -348,11 +353,11 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { match expr { // ( stmt ) - Expr::Stmt(stmt, pos) => match optimize_stmt(*stmt, state, true) { + Expr::Stmt(x) => match optimize_stmt(x.0, state, true) { // ( Noop ) -> () Stmt::Noop(_) => { state.set_dirty(); - Expr::Unit(pos) + Expr::Unit(x.1) } // ( expr ) -> expr Stmt::Expr(expr) => { @@ -360,151 +365,128 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { *expr } // ( stmt ) - stmt => Expr::Stmt(Box::new(stmt), pos), + stmt => Expr::Stmt(Box::new((stmt, x.1))), }, // id = expr - Expr::Assignment(id, expr, pos) => match *expr { + Expr::Assignment(x) => match x.1 { //id = id2 = expr2 - Expr::Assignment(id2, expr2, pos2) => match (*id, *id2) { + Expr::Assignment(x2) => match (x.0, x2.0) { // var = var = expr2 -> var = expr2 - (Expr::Variable(var, None, index, sp, _), Expr::Variable(var2, None, _, sp2, _)) - if var == var2 && sp == sp2 => + (Expr::Variable(a), Expr::Variable(b)) + if a.1.is_none() && b.1.is_none() && a.0 == b.0 && a.3 == b.3 => { // Assignment to the same variable - fold state.set_dirty(); - - Expr::Assignment( - Box::new(Expr::Variable(var, None, index, sp, pos)), - Box::new(optimize_expr(*expr2, state)) - , pos - ) + Expr::Assignment(Box::new((Expr::Variable(a), optimize_expr(x2.1, state), x.2))) } // id1 = id2 = expr2 - (id1, id2) => Expr::Assignment( - Box::new(id1), - Box::new(Expr::Assignment(Box::new(id2), Box::new(optimize_expr(*expr2, state)), pos2)), - pos, - ), + (id1, id2) => { + Expr::Assignment(Box::new(( + id1, Expr::Assignment(Box::new((id2, optimize_expr(x2.1, state), x2.2))), x.2, + ))) + } }, // id = expr - expr => Expr::Assignment(id, Box::new(optimize_expr(expr, state)), pos), + expr => Expr::Assignment(Box::new((x.0, optimize_expr(expr, state), x.2))), }, // lhs.rhs #[cfg(not(feature = "no_object"))] - Expr::Dot(lhs, rhs, pos) => match (*lhs, *rhs) { + Expr::Dot(x) => match (x.0, x.1) { // map.string - (Expr::Map(items, pos), Expr::Property(s, _)) if items.iter().all(|(_, x, _)| x.is_pure()) => { + (Expr::Map(m), Expr::Property(p)) if m.0.iter().all(|(_, x, _)| x.is_pure()) => { // Map literal where everything is pure - promote the indexed item. // All other items can be thrown away. state.set_dirty(); - items.into_iter().find(|(name, _, _)| name == &s) + let pos = m.1; + m.0.into_iter().find(|(name, _, _)| name == &p.0) .map(|(_, expr, _)| expr.set_position(pos)) .unwrap_or_else(|| Expr::Unit(pos)) } // lhs.rhs - (lhs, rhs) => Expr::Dot( - Box::new(optimize_expr(lhs, state)), - Box::new(optimize_expr(rhs, state)), - pos, - ) + (lhs, rhs) => Expr::Dot(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))) } // lhs[rhs] #[cfg(not(feature = "no_index"))] - Expr::Index(lhs, rhs, pos) => match (*lhs, *rhs) { + Expr::Index(x) => match (x.0, x.1) { // array[int] - (Expr::Array(mut items, pos), Expr::IntegerConstant(i, _)) - if i >= 0 && (i as usize) < items.len() && items.iter().all(Expr::is_pure) => + (Expr::Array(mut a), Expr::IntegerConstant(i)) + if i.0 >= 0 && (i.0 as usize) < a.0.len() && a.0.iter().all(Expr::is_pure) => { // Array literal where everything is pure - promote the indexed item. // All other items can be thrown away. state.set_dirty(); - items.remove(i as usize).set_position(pos) + a.0.remove(i.0 as usize).set_position(a.1) } // map[string] - (Expr::Map(items, pos), Expr::StringConstant(s, _)) if items.iter().all(|(_, x, _)| x.is_pure()) => { + (Expr::Map(m), Expr::StringConstant(s)) if m.0.iter().all(|(_, x, _)| x.is_pure()) => { // Map literal where everything is pure - promote the indexed item. // All other items can be thrown away. state.set_dirty(); - items.into_iter().find(|(name, _, _)| name == &s) + let pos = m.1; + m.0.into_iter().find(|(name, _, _)| name == &s.0) .map(|(_, expr, _)| expr.set_position(pos)) .unwrap_or_else(|| Expr::Unit(pos)) } // string[int] - (Expr::StringConstant(s, pos), Expr::IntegerConstant(i, _)) if i >= 0 && (i as usize) < s.chars().count() => { + (Expr::StringConstant(s), Expr::IntegerConstant(i)) if i.0 >= 0 && (i.0 as usize) < s.0.chars().count() => { // String literal indexing - get the character state.set_dirty(); - Expr::CharConstant(s.chars().nth(i as usize).expect("should get char"), pos) + Expr::CharConstant(Box::new((s.0.chars().nth(i.0 as usize).expect("should get char"), s.1))) } // lhs[rhs] - (lhs, rhs) => Expr::Index( - Box::new(optimize_expr(lhs, state)), - Box::new(optimize_expr(rhs, state)), - pos, - ), + (lhs, rhs) => Expr::Index(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))), }, // [ items .. ] #[cfg(not(feature = "no_index"))] - Expr::Array(items, pos) => Expr::Array(items - .into_iter() - .map(|expr| optimize_expr(expr, state)) - .collect(), pos), + Expr::Array(a) => Expr::Array(Box::new((a.0 + .into_iter() + .map(|expr| optimize_expr(expr, state)) + .collect(), a.1))), // [ items .. ] #[cfg(not(feature = "no_object"))] - Expr::Map(items, pos) => Expr::Map(items - .into_iter() - .map(|(key, expr, pos)| (key, optimize_expr(expr, state), pos)) - .collect(), pos), + Expr::Map(m) => Expr::Map(Box::new((m.0 + .into_iter() + .map(|(key, expr, pos)| (key, optimize_expr(expr, state), pos)) + .collect(), m.1))), // lhs in rhs - Expr::In(lhs, rhs, pos) => match (*lhs, *rhs) { + Expr::In(x) => match (x.0, x.1) { // "xxx" in "xxxxx" - (Expr::StringConstant(lhs, pos), Expr::StringConstant(rhs, _)) => { + (Expr::StringConstant(a), Expr::StringConstant(b)) => { state.set_dirty(); - if rhs.contains(&lhs) { - Expr::True(pos) - } else { - Expr::False(pos) - } + if b.0.contains(&a.0) { Expr::True(a.1) } else { Expr::False(a.1) } } // 'x' in "xxxxx" - (Expr::CharConstant(lhs, pos), Expr::StringConstant(rhs, _)) => { + (Expr::CharConstant(a), Expr::StringConstant(b)) => { state.set_dirty(); - if rhs.contains(&lhs.to_string()) { - Expr::True(pos) - } else { - Expr::False(pos) - } + if b.0.contains(a.0) { Expr::True(a.1) } else { Expr::False(a.1) } } // "xxx" in #{...} - (Expr::StringConstant(lhs, pos), Expr::Map(items, _)) => { + (Expr::StringConstant(a), Expr::Map(b)) => { state.set_dirty(); - if items.iter().find(|(name, _, _)| name == &lhs).is_some() { - Expr::True(pos) + if b.0.iter().find(|(name, _, _)| name == &a.0).is_some() { + Expr::True(a.1) } else { - Expr::False(pos) + Expr::False(a.1) } } // 'x' in #{...} - (Expr::CharConstant(lhs, pos), Expr::Map(items, _)) => { + (Expr::CharConstant(a), Expr::Map(b)) => { state.set_dirty(); - let lhs = lhs.to_string(); + let ch = a.0.to_string(); - if items.iter().find(|(name, _, _)| name == &lhs).is_some() { - Expr::True(pos) + if b.0.iter().find(|(name, _, _)| name == &ch).is_some() { + Expr::True(a.1) } else { - Expr::False(pos) + Expr::False(a.1) } } // lhs in rhs - (lhs, rhs) => Expr::In( - Box::new(optimize_expr(lhs, state)), - Box::new(optimize_expr(rhs, state)), - pos - ), + (lhs, rhs) => Expr::In(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))), }, // lhs && rhs - Expr::And(lhs, rhs, pos) => match (*lhs, *rhs) { + Expr::And(x) => match (x.0, x.1) { // true && rhs -> rhs (Expr::True(_), rhs) => { state.set_dirty(); @@ -521,14 +503,10 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { optimize_expr(lhs, state) } // lhs && rhs - (lhs, rhs) => Expr::And( - Box::new(optimize_expr(lhs, state)), - Box::new(optimize_expr(rhs, state)), - pos - ), + (lhs, rhs) => Expr::And(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))), }, // lhs || rhs - Expr::Or(lhs, rhs, pos) => match (*lhs, *rhs) { + Expr::Or(x) => match (x.0, x.1) { // false || rhs -> rhs (Expr::False(_), rhs) => { state.set_dirty(); @@ -545,36 +523,40 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { optimize_expr(lhs, state) } // lhs || rhs - (lhs, rhs) => Expr::Or(Box::new(optimize_expr(lhs, state)), Box::new(optimize_expr(rhs, state)), pos), + (lhs, rhs) => Expr::Or(Box::new((optimize_expr(lhs, state), optimize_expr(rhs, state), x.2))), }, // Do not call some special keywords - Expr::FnCall(id, None, index, args, def_value, pos) if DONT_EVAL_KEYWORDS.contains(&id.as_ref().as_ref())=> - Expr::FnCall(id, None, index, Box::new(args.into_iter().map(|a| optimize_expr(a, state)).collect()), def_value, pos), + Expr::FnCall(mut x) if DONT_EVAL_KEYWORDS.contains(&x.0.as_ref().as_ref())=> { + x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect(); + Expr::FnCall(x) + } // Eagerly call functions - Expr::FnCall(id, None, index, args, def_value, pos) - if state.optimization_level == OptimizationLevel::Full // full optimizations - && args.iter().all(|expr| expr.is_constant()) // all arguments are constants + Expr::FnCall(mut x) + if x.1.is_none() // Non-qualified + && state.optimization_level == OptimizationLevel::Full // full optimizations + && x.3.iter().all(|expr| expr.is_constant()) // all arguments are constants => { // First search in script-defined functions (can override built-in) - if state.fn_lib.iter().find(|(name, len)| name == id.as_ref() && *len == args.len()).is_some() { + if state.fn_lib.iter().find(|(name, len)| *name == x.0 && *len == x.3.len()).is_some() { // A script-defined function overrides the built-in function - do not make the call - return Expr::FnCall(id, None, index, Box::new(args.into_iter().map(|a| optimize_expr(a, state)).collect()), def_value, pos); + x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect(); + return Expr::FnCall(x); } - let mut arg_values: Vec<_> = args.iter().map(Expr::get_constant_value).collect(); + let mut arg_values: Vec<_> = x.3.iter().map(Expr::get_constant_value).collect(); let mut call_args: Vec<_> = arg_values.iter_mut().collect(); // Save the typename of the first argument if it is `type_of()` // This is to avoid `call_args` being passed into the closure - let arg_for_type_of = if *id == KEYWORD_TYPE_OF && call_args.len() == 1 { + let arg_for_type_of = if x.0 == KEYWORD_TYPE_OF && call_args.len() == 1 { state.engine.map_type_name(call_args[0].type_name()) } else { "" }; - call_fn(&state.engine.packages, &state.engine.base_package, &id, &mut call_args, pos).ok() + call_fn(&state.engine.packages, &state.engine.base_package, &x.0, &mut call_args, x.5).ok() .and_then(|result| result.or_else(|| { if !arg_for_type_of.is_empty() { @@ -582,29 +564,32 @@ fn optimize_expr<'a>(expr: Expr, state: &mut State<'a>) -> Expr { Some(arg_for_type_of.to_string().into()) } else { // Otherwise use the default value, if any - def_value.clone().map(|v| *v) + x.4.clone().map(|v| *v) } - }).and_then(|result| map_dynamic_to_expr(result, pos)) + }).and_then(|result| map_dynamic_to_expr(result, x.5)) .map(|expr| { state.set_dirty(); expr }) - ).unwrap_or_else(|| + ).unwrap_or_else(|| { // Optimize function call arguments - Expr::FnCall(id, None, index, Box::new(args.into_iter().map(|a| optimize_expr(a, state)).collect()), def_value, pos) - ) + x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect(); + Expr::FnCall(x) + }) } // id(args ..) -> optimize function call arguments - Expr::FnCall(id, modules, index, args, def_value, pos) => - Expr::FnCall(id, modules, index, Box::new(args.into_iter().map(|a| optimize_expr(a, state)).collect()), def_value, pos), + Expr::FnCall(mut x) => { + x.3 = x.3.into_iter().map(|a| optimize_expr(a, state)).collect(); + Expr::FnCall(x) + } // constant-name - Expr::Variable(name, None, _, _, pos) if state.contains_constant(&name) => { + Expr::Variable(x) if x.1.is_none() && state.contains_constant(&x.0) => { state.set_dirty(); // Replace constant with value - state.find_constant(&name).expect("should find constant in scope!").clone().set_position(pos) + state.find_constant(&x.0).expect("should find constant in scope!").clone().set_position(x.4) } // All other expressions - skip @@ -657,17 +642,17 @@ fn optimize<'a>( .into_iter() .enumerate() .map(|(i, stmt)| { - match stmt { - Stmt::Const(ref name, ref value, _) => { + match &stmt { + Stmt::Const(x) => { // Load constants - state.push_constant(name.as_ref(), value.as_ref().clone()); + state.push_constant(&x.0, x.1.clone()); stmt // Keep it in the global scope } _ => { // Keep all variable declarations at this level // and always keep the last return value let keep = match stmt { - Stmt::Let(_, _, _) | Stmt::Import(_, _, _) => true, + Stmt::Let(_) | Stmt::Import(_) => true, _ => i == num_statements - 1, }; optimize_stmt(stmt, &mut state, keep) @@ -728,19 +713,21 @@ pub fn optimize_into_ast( // Optimize the function body let mut body = - optimize(vec![*fn_def.body], engine, &Scope::new(), &fn_lib, level); + optimize(vec![fn_def.body], engine, &Scope::new(), &fn_lib, level); // {} -> Noop - fn_def.body = Box::new(match body.pop().unwrap_or_else(|| Stmt::Noop(pos)) { + fn_def.body = match body.pop().unwrap_or_else(|| Stmt::Noop(pos)) { // { return val; } -> val - Stmt::ReturnWithVal(Some(val), ReturnType::Return, _) => Stmt::Expr(val), + Stmt::ReturnWithVal(x) if x.0.is_some() && x.1 == ReturnType::Return => { + Stmt::Expr(Box::new(x.0.unwrap())) + } // { return; } -> () - Stmt::ReturnWithVal(None, ReturnType::Return, pos) => { - Stmt::Expr(Box::new(Expr::Unit(pos))) + Stmt::ReturnWithVal(x) if x.0.is_none() && x.1 == ReturnType::Return => { + Stmt::Expr(Box::new(Expr::Unit(x.2))) } // All others stmt => stmt, - }); + }; } fn_def }) diff --git a/src/parser.rs b/src/parser.rs index fbca086e..7a88abfc 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -197,7 +197,7 @@ pub struct FnDef { /// Names of function parameters. pub params: Vec, /// Function body. - pub body: Box, + pub body: Stmt, /// Position of the function definition. pub pos: Position, } @@ -272,19 +272,19 @@ pub enum Stmt { /// No-op. Noop(Position), /// if expr { stmt } else { stmt } - IfThenElse(Box, Box, Option>), + IfThenElse(Box<(Expr, Stmt, Option)>), /// while expr { stmt } - While(Box, Box), + While(Box<(Expr, Stmt)>), /// loop { stmt } Loop(Box), /// for id in expr { stmt } - For(Box, Box, Box), + For(Box<(String, Expr, Stmt)>), /// let id = expr - Let(Box, Option>, Position), + Let(Box<(String, Option, Position)>), /// const id = expr - Const(Box, Box, Position), + Const(Box<(String, Expr, Position)>), /// { stmt; ... } - Block(Vec, Position), + Block(Box<(Vec, Position)>), /// { stmt } Expr(Box), /// continue @@ -292,54 +292,52 @@ pub enum Stmt { /// break Break(Position), /// return/throw - ReturnWithVal(Option>, ReturnType, Position), + ReturnWithVal(Box<(Option, ReturnType, Position)>), /// import expr as module - Import(Box, Box, Position), + Import(Box<(Expr, String, Position)>), /// expr id as name, ... - Export(Vec<(String, Position, Option<(String, Position)>)>), + Export(Box)>>), } impl Stmt { /// Get the `Position` of this statement. pub fn position(&self) -> Position { match self { - Stmt::Noop(pos) - | Stmt::Let(_, _, pos) - | Stmt::Const(_, _, pos) - | Stmt::Import(_, _, pos) - | Stmt::Block(_, pos) - | Stmt::Continue(pos) - | Stmt::Break(pos) - | Stmt::ReturnWithVal(_, _, pos) => *pos, - - Stmt::IfThenElse(expr, _, _) | Stmt::Expr(expr) => expr.position(), - - Stmt::While(_, stmt) | Stmt::Loop(stmt) | Stmt::For(_, _, stmt) => stmt.position(), - - Stmt::Export(list) => list.get(0).unwrap().1, + Stmt::Noop(pos) | Stmt::Continue(pos) | Stmt::Break(pos) => *pos, + Stmt::Let(x) => x.2, + Stmt::Const(x) => x.2, + Stmt::ReturnWithVal(x) => x.2, + Stmt::Block(x) => x.1, + Stmt::IfThenElse(x) => x.0.position(), + Stmt::Expr(x) => x.position(), + Stmt::While(x) => x.1.position(), + Stmt::Loop(x) => x.position(), + Stmt::For(x) => x.2.position(), + Stmt::Import(x) => x.2, + Stmt::Export(x) => x.get(0).unwrap().1, } } /// Is this statement self-terminated (i.e. no need for a semicolon terminator)? pub fn is_self_terminated(&self) -> bool { match self { - Stmt::IfThenElse(_, _, _) - | Stmt::While(_, _) + Stmt::IfThenElse(_) + | Stmt::While(_) | Stmt::Loop(_) - | Stmt::For(_, _, _) - | Stmt::Block(_, _) => true, + | Stmt::For(_) + | Stmt::Block(_) => true, // A No-op requires a semicolon in order to know it is an empty statement! Stmt::Noop(_) => false, - Stmt::Let(_, _, _) - | Stmt::Const(_, _, _) - | Stmt::Import(_, _, _) + Stmt::Let(_) + | Stmt::Const(_) + | Stmt::Import(_) | Stmt::Export(_) | Stmt::Expr(_) | Stmt::Continue(_) | Stmt::Break(_) - | Stmt::ReturnWithVal(_, _, _) => false, + | Stmt::ReturnWithVal(_) => false, } } @@ -348,76 +346,74 @@ impl Stmt { match self { Stmt::Noop(_) => true, Stmt::Expr(expr) => expr.is_pure(), - Stmt::IfThenElse(guard, if_block, Some(else_block)) => { - guard.is_pure() && if_block.is_pure() && else_block.is_pure() + Stmt::IfThenElse(x) if x.2.is_some() => { + x.0.is_pure() && x.1.is_pure() && x.2.as_ref().unwrap().is_pure() } - Stmt::IfThenElse(guard, block, None) | Stmt::While(guard, block) => { - guard.is_pure() && block.is_pure() - } - Stmt::Loop(block) => block.is_pure(), - Stmt::For(_, range, block) => range.is_pure() && block.is_pure(), - Stmt::Let(_, _, _) | Stmt::Const(_, _, _) => false, - Stmt::Block(statements, _) => statements.iter().all(Stmt::is_pure), - Stmt::Continue(_) | Stmt::Break(_) | Stmt::ReturnWithVal(_, _, _) => false, - Stmt::Import(_, _, _) => false, + Stmt::IfThenElse(x) => x.1.is_pure(), + Stmt::While(x) => x.0.is_pure() && x.1.is_pure(), + Stmt::Loop(x) => x.is_pure(), + Stmt::For(x) => x.1.is_pure() && x.2.is_pure(), + Stmt::Let(_) | Stmt::Const(_) => false, + Stmt::Block(x) => x.0.iter().all(Stmt::is_pure), + Stmt::Continue(_) | Stmt::Break(_) | Stmt::ReturnWithVal(_) => false, + Stmt::Import(_) => false, Stmt::Export(_) => false, } } } +#[cfg(not(feature = "no_module"))] +type MRef = Option>; +#[cfg(feature = "no_module")] +type MRef = Option; + /// An expression. #[derive(Debug, Clone)] pub enum Expr { /// Integer constant. - IntegerConstant(INT, Position), + IntegerConstant(Box<(INT, Position)>), /// Floating-point constant. #[cfg(not(feature = "no_float"))] - FloatConstant(FLOAT, Position), + FloatConstant(Box<(FLOAT, Position)>), /// Character constant. - CharConstant(char, Position), + CharConstant(Box<(char, Position)>), /// String constant. - StringConstant(String, Position), + StringConstant(Box<(String, Position)>), /// Variable access - (variable name, optional modules, hash, optional index, position) - Variable( - Box, - #[cfg(not(feature = "no_module"))] Option>, - #[cfg(feature = "no_module")] Option, - u64, - Option, - Position, - ), + Variable(Box<(String, MRef, u64, Option, Position)>), /// Property access. - Property(String, Position), + Property(Box<(String, Position)>), /// { stmt } - Stmt(Box, Position), + Stmt(Box<(Stmt, Position)>), /// func(expr, ... ) - (function name, optional modules, hash, arguments, optional default value, position) /// Use `Cow<'static, str>` because a lot of operators (e.g. `==`, `>=`) are implemented as function calls /// and the function names are predictable, so no need to allocate a new `String`. FnCall( - Box>, - #[cfg(not(feature = "no_module"))] Option>, - #[cfg(feature = "no_module")] Option, - u64, - Box>, - Option>, - Position, + Box<( + Cow<'static, str>, + MRef, + u64, + Vec, + Option>, + Position, + )>, ), /// expr = expr - Assignment(Box, Box, Position), + Assignment(Box<(Expr, Expr, Position)>), /// lhs.rhs - Dot(Box, Box, Position), + Dot(Box<(Expr, Expr, Position)>), /// expr[expr] - Index(Box, Box, Position), + Index(Box<(Expr, Expr, Position)>), /// [ expr, ... ] - Array(Vec, Position), + Array(Box<(Vec, Position)>), /// #{ name:expr, ... } - Map(Vec<(String, Expr, Position)>, Position), + Map(Box<(Vec<(String, Expr, Position)>, Position)>), /// lhs in rhs - In(Box, Box, Position), + In(Box<(Expr, Expr, Position)>), /// lhs && rhs - And(Box, Box, Position), + And(Box<(Expr, Expr, Position)>), /// lhs || rhs - Or(Box, Box, Position), + Or(Box<(Expr, Expr, Position)>), /// true True(Position), /// false @@ -434,30 +430,24 @@ impl Expr { /// Panics when the expression is not constant. pub fn get_constant_value(&self) -> Dynamic { match self { - Self::IntegerConstant(i, _) => (*i).into(), + Self::IntegerConstant(x) => x.0.into(), #[cfg(not(feature = "no_float"))] - Self::FloatConstant(f, _) => (*f).into(), - Self::CharConstant(c, _) => (*c).into(), - Self::StringConstant(s, _) => s.clone().into(), + Self::FloatConstant(x) => x.0.into(), + Self::CharConstant(x) => x.0.into(), + Self::StringConstant(x) => x.0.clone().into(), Self::True(_) => true.into(), Self::False(_) => false.into(), Self::Unit(_) => ().into(), #[cfg(not(feature = "no_index"))] - Self::Array(items, _) if items.iter().all(Self::is_constant) => { - Dynamic(Union::Array(Box::new( - items - .iter() - .map(Self::get_constant_value) - .collect::>(), - ))) - } + Self::Array(x) if x.0.iter().all(Self::is_constant) => Dynamic(Union::Array(Box::new( + x.0.iter().map(Self::get_constant_value).collect::>(), + ))), #[cfg(not(feature = "no_object"))] - Self::Map(items, _) if items.iter().all(|(_, v, _)| v.is_constant()) => { + Self::Map(x) if x.0.iter().all(|(_, v, _)| v.is_constant()) => { Dynamic(Union::Map(Box::new( - items - .iter() + x.0.iter() .map(|(k, v, _)| (k.clone(), v.get_constant_value())) .collect::>(), ))) @@ -475,16 +465,16 @@ impl Expr { pub fn get_constant_str(&self) -> String { match self { #[cfg(not(feature = "no_float"))] - Self::FloatConstant(f, _) => f.to_string(), + Self::FloatConstant(x) => x.0.to_string(), - Self::IntegerConstant(i, _) => i.to_string(), - Self::CharConstant(c, _) => c.to_string(), - Self::StringConstant(_, _) => "string".to_string(), + Self::IntegerConstant(x) => x.0.to_string(), + Self::CharConstant(x) => x.0.to_string(), + Self::StringConstant(_) => "string".to_string(), Self::True(_) => "true".to_string(), Self::False(_) => "false".to_string(), Self::Unit(_) => "()".to_string(), - Self::Array(items, _) if items.iter().all(Self::is_constant) => "array".to_string(), + Self::Array(x) if x.0.iter().all(Self::is_constant) => "array".to_string(), _ => panic!("cannot get value of non-constant expression"), } @@ -494,27 +484,23 @@ impl Expr { pub fn position(&self) -> Position { match self { #[cfg(not(feature = "no_float"))] - Self::FloatConstant(_, pos) => *pos, + Self::FloatConstant(x) => x.1, - Self::IntegerConstant(_, pos) - | Self::CharConstant(_, pos) - | Self::StringConstant(_, pos) - | Self::Array(_, pos) - | Self::Map(_, pos) - | Self::Variable(_, _, _, _, pos) - | Self::Property(_, pos) - | Self::Stmt(_, pos) - | Self::FnCall(_, _, _, _, _, pos) - | Self::And(_, _, pos) - | Self::Or(_, _, pos) - | Self::In(_, _, pos) - | Self::True(pos) - | Self::False(pos) - | Self::Unit(pos) => *pos, + Self::IntegerConstant(x) => x.1, + Self::CharConstant(x) => x.1, + Self::StringConstant(x) => x.1, + Self::Array(x) => x.1, + Self::Map(x) => x.1, + Self::Property(x) => x.1, + Self::Stmt(x) => x.1, + Self::Variable(x) => x.4, + Self::FnCall(x) => x.5, - Self::Assignment(expr, _, _) | Self::Dot(expr, _, _) | Self::Index(expr, _, _) => { - expr.position() - } + Self::And(x) | Self::Or(x) | Self::In(x) => x.2, + + Self::True(pos) | Self::False(pos) | Self::Unit(pos) => *pos, + + Self::Assignment(x) | Self::Dot(x) | Self::Index(x) => x.0.position(), } } @@ -522,26 +508,26 @@ impl Expr { pub(crate) fn set_position(mut self, new_pos: Position) -> Self { match &mut self { #[cfg(not(feature = "no_float"))] - Self::FloatConstant(_, pos) => *pos = new_pos, + Self::FloatConstant(x) => x.1 = new_pos, - Self::IntegerConstant(_, pos) - | Self::CharConstant(_, pos) - | Self::StringConstant(_, pos) - | Self::Array(_, pos) - | Self::Map(_, pos) - | Self::Variable(_, _, _, _, pos) - | Self::Property(_, pos) - | Self::Stmt(_, pos) - | Self::FnCall(_, _, _, _, _, pos) - | Self::And(_, _, pos) - | Self::Or(_, _, pos) - | Self::In(_, _, pos) - | Self::True(pos) - | Self::False(pos) - | Self::Unit(pos) - | Self::Assignment(_, _, pos) - | Self::Dot(_, _, pos) - | Self::Index(_, _, pos) => *pos = new_pos, + Self::IntegerConstant(x) => x.1 = new_pos, + Self::CharConstant(x) => x.1 = new_pos, + Self::StringConstant(x) => x.1 = new_pos, + Self::Array(x) => x.1 = new_pos, + Self::Map(x) => x.1 = new_pos, + Self::Variable(x) => x.4 = new_pos, + Self::Property(x) => x.1 = new_pos, + Self::Stmt(x) => x.1 = new_pos, + Self::FnCall(x) => x.5 = new_pos, + Self::And(x) => x.2 = new_pos, + Self::Or(x) => x.2 = new_pos, + Self::In(x) => x.2 = new_pos, + Self::True(pos) => *pos = new_pos, + Self::False(pos) => *pos = new_pos, + Self::Unit(pos) => *pos = new_pos, + Self::Assignment(x) => x.2 = new_pos, + Self::Dot(x) => x.2 = new_pos, + Self::Index(x) => x.2 = new_pos, } self @@ -552,15 +538,15 @@ impl Expr { /// A pure expression has no side effects. pub fn is_pure(&self) -> bool { match self { - Self::Array(expressions, _) => expressions.iter().all(Self::is_pure), + Self::Array(x) => x.0.iter().all(Self::is_pure), - Self::Index(x, y, _) | Self::And(x, y, _) | Self::Or(x, y, _) | Self::In(x, y, _) => { - x.is_pure() && y.is_pure() + Self::Index(x) | Self::And(x) | Self::Or(x) | Self::In(x) => { + x.0.is_pure() && x.1.is_pure() } - Self::Stmt(stmt, _) => stmt.is_pure(), + Self::Stmt(x) => x.0.is_pure(), - Self::Variable(_, _, _, _, _) => true, + Self::Variable(_) => true, expr => expr.is_constant(), } @@ -570,25 +556,25 @@ impl Expr { pub fn is_constant(&self) -> bool { match self { #[cfg(not(feature = "no_float"))] - Self::FloatConstant(_, _) => true, + Self::FloatConstant(_) => true, - Self::IntegerConstant(_, _) - | Self::CharConstant(_, _) - | Self::StringConstant(_, _) + Self::IntegerConstant(_) + | Self::CharConstant(_) + | Self::StringConstant(_) | Self::True(_) | Self::False(_) | Self::Unit(_) => true, // An array literal is constant if all items are constant - Self::Array(expressions, _) => expressions.iter().all(Self::is_constant), + Self::Array(x) => x.0.iter().all(Self::is_constant), // An map literal is constant if all items are constant - Self::Map(items, _) => items.iter().map(|(_, expr, _)| expr).all(Self::is_constant), + Self::Map(x) => x.0.iter().map(|(_, expr, _)| expr).all(Self::is_constant), // Check in expression - Self::In(lhs, rhs, _) => match (lhs.as_ref(), rhs.as_ref()) { - (Self::StringConstant(_, _), Self::StringConstant(_, _)) - | (Self::CharConstant(_, _), Self::StringConstant(_, _)) => true, + Self::In(x) => match (&x.0, &x.1) { + (Self::StringConstant(_), Self::StringConstant(_)) + | (Self::CharConstant(_), Self::StringConstant(_)) => true, _ => false, }, @@ -600,37 +586,37 @@ impl Expr { pub fn is_valid_postfix(&self, token: &Token) -> bool { match self { #[cfg(not(feature = "no_float"))] - Self::FloatConstant(_, _) => false, + Self::FloatConstant(_) => false, - Self::IntegerConstant(_, _) - | Self::CharConstant(_, _) - | Self::In(_, _, _) - | Self::And(_, _, _) - | Self::Or(_, _, _) + Self::IntegerConstant(_) + | Self::CharConstant(_) + | Self::In(_) + | Self::And(_) + | Self::Or(_) | Self::True(_) | Self::False(_) | Self::Unit(_) => false, - Self::StringConstant(_, _) - | Self::Stmt(_, _) - | Self::FnCall(_, _, _, _, _, _) - | Self::Assignment(_, _, _) - | Self::Dot(_, _, _) - | Self::Index(_, _, _) - | Self::Array(_, _) - | Self::Map(_, _) => match token { + Self::StringConstant(_) + | Self::Stmt(_) + | Self::FnCall(_) + | Self::Assignment(_) + | Self::Dot(_) + | Self::Index(_) + | Self::Array(_) + | Self::Map(_) => match token { Token::LeftBracket => true, _ => false, }, - Self::Variable(_, _, _, _, _) => match token { + Self::Variable(_) => match token { Token::LeftBracket | Token::LeftParen => true, #[cfg(not(feature = "no_module"))] Token::DoubleColon => true, _ => false, }, - Self::Property(_, _) => match token { + Self::Property(_) => match token { Token::LeftBracket | Token::LeftParen => true, _ => false, }, @@ -640,7 +626,7 @@ impl Expr { /// Convert a `Variable` into a `Property`. All other variants are untouched. pub(crate) fn into_property(self) -> Self { match self { - Self::Variable(id, None, _, _, pos) => Self::Property(*id, pos), + Self::Variable(x) if x.1.is_none() => Self::Property(Box::new((x.0.clone(), x.4))), _ => self, } } @@ -748,14 +734,14 @@ fn parse_call_expr<'a>( #[cfg(feature = "no_module")] let hash1 = calc_fn_hash(empty(), &id, empty()); - return Ok(Expr::FnCall( - Box::new(id.into()), + return Ok(Expr::FnCall(Box::new(( + id.into(), modules, hash1, - Box::new(args), + args, None, begin, - )); + )))); } // id... _ => (), @@ -795,14 +781,14 @@ fn parse_call_expr<'a>( #[cfg(feature = "no_module")] let hash1 = calc_fn_hash(empty(), &id, repeat(EMPTY_TYPE_ID()).take(args.len())); - return Ok(Expr::FnCall( - Box::new(id.into()), + return Ok(Expr::FnCall(Box::new(( + id.into(), modules, hash1, - Box::new(args), + args, None, begin, - )); + )))); } // id(...args, (Token::Comma, _) => { @@ -846,39 +832,44 @@ fn parse_index_chain<'a>( // Check type of indexing - must be integer or string match &idx_expr { // lhs[int] - Expr::IntegerConstant(i, pos) if *i < 0 => { + Expr::IntegerConstant(x) if x.0 < 0 => { return Err(PERR::MalformedIndexExpr(format!( "Array access expects non-negative index: {} < 0", - i + x.0 )) - .into_err(*pos)) + .into_err(x.1)) } - Expr::IntegerConstant(_, pos) => match lhs { - Expr::Array(_, _) | Expr::StringConstant(_, _) => (), + Expr::IntegerConstant(x) => match lhs { + Expr::Array(_) | Expr::StringConstant(_) => (), - Expr::Map(_, _) => { + Expr::Map(_) => { return Err(PERR::MalformedIndexExpr( "Object map access expects string index, not a number".into(), ) - .into_err(*pos)) + .into_err(x.1)) } #[cfg(not(feature = "no_float"))] - Expr::FloatConstant(_, pos) => { + Expr::FloatConstant(x) => { return Err(PERR::MalformedIndexExpr( "Only arrays, object maps and strings can be indexed".into(), ) - .into_err(pos)) + .into_err(x.1)) } - Expr::CharConstant(_, pos) - | Expr::Assignment(_, _, pos) - | Expr::And(_, _, pos) - | Expr::Or(_, _, pos) - | Expr::In(_, _, pos) - | Expr::True(pos) - | Expr::False(pos) - | Expr::Unit(pos) => { + Expr::CharConstant(x) => { + return Err(PERR::MalformedIndexExpr( + "Only arrays, object maps and strings can be indexed".into(), + ) + .into_err(x.1)) + } + Expr::Assignment(x) | Expr::And(x) | Expr::Or(x) | Expr::In(x) => { + return Err(PERR::MalformedIndexExpr( + "Only arrays, object maps and strings can be indexed".into(), + ) + .into_err(x.2)) + } + Expr::True(pos) | Expr::False(pos) | Expr::Unit(pos) => { return Err(PERR::MalformedIndexExpr( "Only arrays, object maps and strings can be indexed".into(), ) @@ -889,32 +880,39 @@ fn parse_index_chain<'a>( }, // lhs[string] - Expr::StringConstant(_, pos) => match lhs { - Expr::Map(_, _) => (), + Expr::StringConstant(x) => match lhs { + Expr::Map(_) => (), - Expr::Array(_, _) | Expr::StringConstant(_, _) => { + Expr::Array(_) | Expr::StringConstant(_) => { return Err(PERR::MalformedIndexExpr( "Array or string expects numeric index, not a string".into(), ) - .into_err(*pos)) + .into_err(x.1)) } #[cfg(not(feature = "no_float"))] - Expr::FloatConstant(_, pos) => { + Expr::FloatConstant(x) => { return Err(PERR::MalformedIndexExpr( "Only arrays, object maps and strings can be indexed".into(), ) - .into_err(pos)) + .into_err(x.1)) } - Expr::CharConstant(_, pos) - | Expr::Assignment(_, _, pos) - | Expr::And(_, _, pos) - | Expr::Or(_, _, pos) - | Expr::In(_, _, pos) - | Expr::True(pos) - | Expr::False(pos) - | Expr::Unit(pos) => { + Expr::CharConstant(x) => { + return Err(PERR::MalformedIndexExpr( + "Only arrays, object maps and strings can be indexed".into(), + ) + .into_err(x.1)) + } + + Expr::Assignment(x) | Expr::And(x) | Expr::Or(x) | Expr::In(x) => { + return Err(PERR::MalformedIndexExpr( + "Only arrays, object maps and strings can be indexed".into(), + ) + .into_err(x.2)) + } + + Expr::True(pos) | Expr::False(pos) | Expr::Unit(pos) => { return Err(PERR::MalformedIndexExpr( "Only arrays, object maps and strings can be indexed".into(), ) @@ -926,32 +924,42 @@ fn parse_index_chain<'a>( // lhs[float] #[cfg(not(feature = "no_float"))] - Expr::FloatConstant(_, pos) => { + Expr::FloatConstant(x) => { return Err(PERR::MalformedIndexExpr( "Array access expects integer index, not a float".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // lhs[char] - Expr::CharConstant(_, pos) => { + Expr::CharConstant(x) => { return Err(PERR::MalformedIndexExpr( "Array access expects integer index, not a character".into(), ) - .into_err(*pos)) + .into_err(x.1)) } - // lhs[??? = ??? ], lhs[()] - Expr::Assignment(_, _, pos) | Expr::Unit(pos) => { + // lhs[??? = ??? ] + Expr::Assignment(x) => { + return Err(PERR::MalformedIndexExpr( + "Array access expects integer index, not ()".into(), + ) + .into_err(x.2)) + } + // lhs[()] + Expr::Unit(pos) => { return Err(PERR::MalformedIndexExpr( "Array access expects integer index, not ()".into(), ) .into_err(*pos)) } - // lhs[??? && ???], lhs[??? || ???], lhs[??? in ???], lhs[true], lhs[false] - Expr::And(_, _, pos) - | Expr::Or(_, _, pos) - | Expr::In(_, _, pos) - | Expr::True(pos) - | Expr::False(pos) => { + // lhs[??? && ???], lhs[??? || ???], lhs[??? in ???] + Expr::And(x) | Expr::Or(x) | Expr::In(x) => { + return Err(PERR::MalformedIndexExpr( + "Array access expects integer index, not a boolean".into(), + ) + .into_err(x.2)) + } + // lhs[true], lhs[false] + Expr::True(pos) | Expr::False(pos) => { return Err(PERR::MalformedIndexExpr( "Array access expects integer index, not a boolean".into(), ) @@ -975,10 +983,10 @@ fn parse_index_chain<'a>( let follow = parse_index_chain(input, stack, idx_expr, follow_pos, allow_stmt_expr)?; // Indexing binds to right - Ok(Expr::Index(Box::new(lhs), Box::new(follow), pos)) + Ok(Expr::Index(Box::new((lhs, follow, pos)))) } // Otherwise terminate the indexing chain - _ => Ok(Expr::Index(Box::new(lhs), Box::new(idx_expr), pos)), + _ => Ok(Expr::Index(Box::new((lhs, idx_expr, pos)))), } } (Token::LexError(err), pos) => return Err(PERR::BadInput(err.to_string()).into_err(*pos)), @@ -1030,7 +1038,7 @@ fn parse_array_literal<'a>( } } - Ok(Expr::Array(arr, pos)) + Ok(Expr::Array(Box::new((arr, pos)))) } /// Parse a map literal. @@ -1127,7 +1135,7 @@ fn parse_map_literal<'a>( }) .map_err(|(key, pos)| PERR::DuplicatedProperty(key.to_string()).into_err(pos))?; - Ok(Expr::Map(map, pos)) + Ok(Expr::Map(Box::new((map, pos)))) } /// Parse a primary expression. @@ -1141,21 +1149,21 @@ fn parse_primary<'a>( (Token::LeftBrace, pos) if allow_stmt_expr => { let pos = *pos; return parse_block(input, stack, false, allow_stmt_expr) - .map(|block| Expr::Stmt(Box::new(block), pos)); + .map(|block| Expr::Stmt(Box::new((block, pos)))); } (Token::EOF, pos) => return Err(PERR::UnexpectedEOF.into_err(*pos)), _ => input.next().unwrap(), }; let mut root_expr = match token { - Token::IntegerConstant(x) => Expr::IntegerConstant(x, pos), + Token::IntegerConstant(x) => Expr::IntegerConstant(Box::new((x, pos))), #[cfg(not(feature = "no_float"))] - Token::FloatConstant(x) => Expr::FloatConstant(x, pos), - Token::CharConstant(c) => Expr::CharConstant(c, pos), - Token::StringConst(s) => Expr::StringConstant(s, pos), + Token::FloatConstant(x) => Expr::FloatConstant(Box::new((x, pos))), + Token::CharConstant(c) => Expr::CharConstant(Box::new((c, pos))), + Token::StringConst(s) => Expr::StringConstant(Box::new((s, pos))), Token::Identifier(s) => { let index = stack.find(&s); - Expr::Variable(Box::new(s), None, 0, index, pos) + Expr::Variable(Box::new((s, None, 0, index, pos))) } Token::LeftParen => parse_paren_expr(input, stack, pos, allow_stmt_expr)?, #[cfg(not(feature = "no_index"))] @@ -1182,30 +1190,28 @@ fn parse_primary<'a>( root_expr = match (root_expr, token) { // Function call - (Expr::Variable(id, modules, _, _, pos), Token::LeftParen) => { - parse_call_expr(input, stack, *id, modules, pos, allow_stmt_expr)? + (Expr::Variable(x), Token::LeftParen) => { + parse_call_expr(input, stack, x.0, x.1, x.4, allow_stmt_expr)? } - (Expr::Property(id, pos), Token::LeftParen) => { - parse_call_expr(input, stack, id, None, pos, allow_stmt_expr)? + (Expr::Property(x), Token::LeftParen) => { + parse_call_expr(input, stack, x.0, None, x.1, allow_stmt_expr)? } // module access #[cfg(not(feature = "no_module"))] - (Expr::Variable(id, mut modules, _, index, pos), Token::DoubleColon) => { - match input.next().unwrap() { - (Token::Identifier(id2), pos2) => { - if let Some(ref mut modules) = modules { - modules.push((*id, pos)); - } else { - let mut m: ModuleRef = Default::default(); - m.push((*id, pos)); - modules = Some(Box::new(m)); - } - - Expr::Variable(Box::new(id2), modules, 0, index, pos2) + (Expr::Variable(mut x), Token::DoubleColon) => match input.next().unwrap() { + (Token::Identifier(id2), pos2) => { + if let Some(ref mut modules) = x.1 { + modules.push((x.0, x.4)); + } else { + let mut m: ModuleRef = Default::default(); + m.push((x.0, x.4)); + x.1 = Some(Box::new(m)); } - (_, pos2) => return Err(PERR::VariableExpected.into_err(pos2)), + + Expr::Variable(Box::new((id2, x.1, 0, x.3, pos2))) } - } + (_, pos2) => return Err(PERR::VariableExpected.into_err(pos2)), + }, // Indexing #[cfg(not(feature = "no_index"))] (expr, Token::LeftBracket) => { @@ -1219,9 +1225,11 @@ fn parse_primary<'a>( match &mut root_expr { // Cache the hash key for module-qualified variables #[cfg(not(feature = "no_module"))] - Expr::Variable(id, Some(modules), hash, _, _) => { + Expr::Variable(x) if x.1.is_some() => { + let modules = x.1.as_mut().unwrap(); + // Qualifiers + variable name - *hash = calc_fn_hash(modules.iter().map(|(v, _)| v.as_str()), id, empty()); + x.2 = calc_fn_hash(modules.iter().map(|(v, _)| v.as_str()), &x.0, empty()); modules.set_index(stack.find_module(&modules.get(0).0)); } _ => (), @@ -1240,10 +1248,10 @@ fn parse_unary<'a>( // If statement is allowed to act as expressions (Token::If, pos) => { let pos = *pos; - Ok(Expr::Stmt( - Box::new(parse_if(input, stack, false, allow_stmt_expr)?), + Ok(Expr::Stmt(Box::new(( + parse_if(input, stack, false, allow_stmt_expr)?, pos, - )) + )))) } // -expr (Token::UnaryMinus, _) => { @@ -1251,41 +1259,46 @@ fn parse_unary<'a>( match parse_unary(input, stack, allow_stmt_expr)? { // Negative integer - Expr::IntegerConstant(i, _) => i - .checked_neg() - .map(|x| Expr::IntegerConstant(x, pos)) - .or_else(|| { - #[cfg(not(feature = "no_float"))] - { - Some(Expr::FloatConstant(-(i as FLOAT), pos)) - } - #[cfg(feature = "no_float")] - { - None - } - }) - .ok_or_else(|| { - PERR::BadInput(LexError::MalformedNumber(format!("-{}", i)).to_string()) + Expr::IntegerConstant(x) => { + let (num, pos) = *x; + + num.checked_neg() + .map(|i| Expr::IntegerConstant(Box::new((i, pos)))) + .or_else(|| { + #[cfg(not(feature = "no_float"))] + { + Some(Expr::FloatConstant(Box::new((-(x.0 as FLOAT), pos)))) + } + #[cfg(feature = "no_float")] + { + None + } + }) + .ok_or_else(|| { + PERR::BadInput( + LexError::MalformedNumber(format!("-{}", x.0)).to_string(), + ) .into_err(pos) - }), + }) + } // Negative float #[cfg(not(feature = "no_float"))] - Expr::FloatConstant(f, pos) => Ok(Expr::FloatConstant(-f, pos)), + Expr::FloatConstant(x) => Ok(Expr::FloatConstant(Box::new((-x.0, x.1)))), // Call negative function e => { let op = "-"; let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2)); - Ok(Expr::FnCall( - Box::new(op.into()), + Ok(Expr::FnCall(Box::new(( + op.into(), None, hash, - Box::new(vec![e]), + vec![e], None, pos, - )) + )))) } } } @@ -1300,14 +1313,14 @@ fn parse_unary<'a>( let op = "!"; let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(2)); - Ok(Expr::FnCall( - Box::new(op.into()), + Ok(Expr::FnCall(Box::new(( + op.into(), None, hash, - Box::new(vec![parse_primary(input, stack, allow_stmt_expr)?]), + vec![parse_primary(input, stack, allow_stmt_expr)?], Some(Box::new(false.into())), // NOT operator, when operating on invalid operand, defaults to false pos, - )) + )))) } // (Token::EOF, pos) => Err(PERR::UnexpectedEOF.into_err(*pos)), @@ -1323,34 +1336,30 @@ fn make_assignment_stmt<'a>( pos: Position, ) -> Result> { match &lhs { - Expr::Variable(_, _, _, None, _) => Ok(Expr::Assignment(Box::new(lhs), Box::new(rhs), pos)), - Expr::Variable(name, _, _, Some(index), var_pos) => { - match stack[(stack.len() - index.get())].1 { - ScopeEntryType::Normal => Ok(Expr::Assignment(Box::new(lhs), Box::new(rhs), pos)), + Expr::Variable(x) if x.3.is_none() => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), + Expr::Variable(x) => { + match stack[(stack.len() - x.3.unwrap().get())].1 { + ScopeEntryType::Normal => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), // Constant values cannot be assigned to ScopeEntryType::Constant => { - Err(PERR::AssignmentToConstant(name.to_string()).into_err(*var_pos)) + Err(PERR::AssignmentToConstant(x.0.to_string()).into_err(x.4)) } ScopeEntryType::Module => unreachable!(), } } - Expr::Index(idx_lhs, _, _) | Expr::Dot(idx_lhs, _, _) => match idx_lhs.as_ref() { - Expr::Variable(_, _, _, None, _) => { - Ok(Expr::Assignment(Box::new(lhs), Box::new(rhs), pos)) - } - Expr::Variable(name, _, _, Some(index), var_pos) => { - match stack[(stack.len() - index.get())].1 { - ScopeEntryType::Normal => { - Ok(Expr::Assignment(Box::new(lhs), Box::new(rhs), pos)) - } + Expr::Index(x) | Expr::Dot(x) => match &x.0 { + Expr::Variable(x) if x.3.is_none() => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), + Expr::Variable(x) => { + match stack[(stack.len() - x.3.unwrap().get())].1 { + ScopeEntryType::Normal => Ok(Expr::Assignment(Box::new((lhs, rhs, pos)))), // Constant values cannot be assigned to ScopeEntryType::Constant => { - Err(PERR::AssignmentToConstant(name.to_string()).into_err(*var_pos)) + Err(PERR::AssignmentToConstant(x.0.to_string()).into_err(x.4)) } ScopeEntryType::Module => unreachable!(), } } - _ => Err(PERR::AssignmentToCopy.into_err(idx_lhs.position())), + _ => Err(PERR::AssignmentToCopy.into_err(x.0.position())), }, expr if expr.is_constant() => { Err(PERR::AssignmentToConstant("".into()).into_err(lhs.position())) @@ -1394,7 +1403,7 @@ fn parse_op_assignment_stmt<'a>( // lhs op= rhs -> lhs = op(lhs, rhs) let args = vec![lhs_copy, rhs]; let hash = calc_fn_hash(empty(), op, repeat(EMPTY_TYPE_ID()).take(args.len())); - let rhs_expr = Expr::FnCall(Box::new(op.into()), None, hash, Box::new(args), None, pos); + let rhs_expr = Expr::FnCall(Box::new((op.into(), None, hash, args, None, pos))); make_assignment_stmt(stack, lhs, rhs_expr, pos) } @@ -1408,59 +1417,64 @@ fn make_dot_expr( Ok(match (lhs, rhs) { // idx_lhs[idx_rhs].rhs // Attach dot chain to the bottom level of indexing chain - (Expr::Index(idx_lhs, idx_rhs, idx_pos), rhs) => Expr::Index( - idx_lhs, - Box::new(make_dot_expr(*idx_rhs, rhs, op_pos, true)?), - idx_pos, - ), + (Expr::Index(x), rhs) => { + Expr::Index(Box::new((x.0, make_dot_expr(x.1, rhs, op_pos, true)?, x.2))) + } // lhs.id - (lhs, rhs @ Expr::Variable(_, None, _, _, _)) | (lhs, rhs @ Expr::Property(_, _)) => { + (lhs, Expr::Variable(x)) if x.1.is_none() => { let lhs = if is_index { lhs.into_property() } else { lhs }; - Expr::Dot(Box::new(lhs), Box::new(rhs.into_property()), op_pos) + Expr::Dot(Box::new(( + lhs, + Expr::Property(Box::new((x.0, x.4))), + op_pos, + ))) + } + (lhs, Expr::Property(x)) => { + let lhs = if is_index { lhs.into_property() } else { lhs }; + Expr::Dot(Box::new((lhs, Expr::Property(x), op_pos))) } // lhs.module::id - syntax error - (_, Expr::Variable(_, Some(modules), _, _, _)) => { + (_, Expr::Variable(x)) if x.1.is_some() => { #[cfg(feature = "no_module")] unreachable!(); #[cfg(not(feature = "no_module"))] - return Err(PERR::PropertyExpected.into_err(modules.get(0).1)); + return Err(PERR::PropertyExpected.into_err(x.1.unwrap().get(0).1)); } // lhs.dot_lhs.dot_rhs - (lhs, Expr::Dot(dot_lhs, dot_rhs, dot_pos)) => Expr::Dot( - Box::new(lhs), - Box::new(Expr::Dot( - Box::new(dot_lhs.into_property()), - Box::new(dot_rhs.into_property()), - dot_pos, - )), + (lhs, Expr::Dot(x)) => Expr::Dot(Box::new(( + lhs, + Expr::Dot(Box::new((x.0.into_property(), x.1.into_property(), x.2))), op_pos, - ), + ))), // lhs.idx_lhs[idx_rhs] - (lhs, Expr::Index(idx_lhs, idx_rhs, idx_pos)) => Expr::Dot( - Box::new(lhs), - Box::new(Expr::Index( - Box::new(idx_lhs.into_property()), - Box::new(idx_rhs.into_property()), - idx_pos, - )), + (lhs, Expr::Index(x)) => Expr::Dot(Box::new(( + lhs, + Expr::Index(Box::new((x.0.into_property(), x.1.into_property(), x.2))), op_pos, - ), + ))), // lhs.rhs - (lhs, rhs) => Expr::Dot(Box::new(lhs), Box::new(rhs.into_property()), op_pos), + (lhs, rhs) => Expr::Dot(Box::new((lhs, rhs.into_property(), op_pos))), }) } /// Make an 'in' expression. fn make_in_expr(lhs: Expr, rhs: Expr, op_pos: Position) -> Result> { match (&lhs, &rhs) { - (_, Expr::IntegerConstant(_, pos)) - | (_, Expr::And(_, _, pos)) - | (_, Expr::Or(_, _, pos)) - | (_, Expr::In(_, _, pos)) - | (_, Expr::True(pos)) - | (_, Expr::False(pos)) - | (_, Expr::Assignment(_, _, pos)) - | (_, Expr::Unit(pos)) => { + (_, Expr::IntegerConstant(x)) => { + return Err(PERR::MalformedInExpr( + "'in' expression expects a string, array or object map".into(), + ) + .into_err(x.1)) + } + + (_, Expr::And(x)) | (_, Expr::Or(x)) | (_, Expr::In(x)) | (_, Expr::Assignment(x)) => { + return Err(PERR::MalformedInExpr( + "'in' expression expects a string, array or object map".into(), + ) + .into_err(x.2)) + } + + (_, Expr::True(pos)) | (_, Expr::False(pos)) | (_, Expr::Unit(pos)) => { return Err(PERR::MalformedInExpr( "'in' expression expects a string, array or object map".into(), ) @@ -1468,61 +1482,72 @@ fn make_in_expr(lhs: Expr, rhs: Expr, op_pos: Position) -> Result { + (_, Expr::FloatConstant(x)) => { return Err(PERR::MalformedInExpr( "'in' expression expects a string, array or object map".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // "xxx" in "xxxx", 'x' in "xxxx" - OK! - (Expr::StringConstant(_, _), Expr::StringConstant(_, _)) - | (Expr::CharConstant(_, _), Expr::StringConstant(_, _)) => (), + (Expr::StringConstant(_), Expr::StringConstant(_)) + | (Expr::CharConstant(_), Expr::StringConstant(_)) => (), // 123.456 in "xxxx" #[cfg(not(feature = "no_float"))] - (Expr::FloatConstant(_, pos), Expr::StringConstant(_, _)) => { + (Expr::FloatConstant(x), Expr::StringConstant(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for a string expects a string, not a float".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // 123 in "xxxx" - (Expr::IntegerConstant(_, pos), Expr::StringConstant(_, _)) => { + (Expr::IntegerConstant(x), Expr::StringConstant(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for a string expects a string, not a number".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // (??? && ???) in "xxxx", (??? || ???) in "xxxx", (??? in ???) in "xxxx", + (Expr::And(x), Expr::StringConstant(_)) + | (Expr::Or(x), Expr::StringConstant(_)) + | (Expr::In(x), Expr::StringConstant(_)) => { + return Err(PERR::MalformedInExpr( + "'in' expression for a string expects a string, not a boolean".into(), + ) + .into_err(x.2)) + } // true in "xxxx", false in "xxxx" - (Expr::And(_, _, pos), Expr::StringConstant(_, _)) - | (Expr::Or(_, _, pos), Expr::StringConstant(_, _)) - | (Expr::In(_, _, pos), Expr::StringConstant(_, _)) - | (Expr::True(pos), Expr::StringConstant(_, _)) - | (Expr::False(pos), Expr::StringConstant(_, _)) => { + (Expr::True(pos), Expr::StringConstant(_)) + | (Expr::False(pos), Expr::StringConstant(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for a string expects a string, not a boolean".into(), ) .into_err(*pos)) } // [???, ???, ???] in "xxxx" - (Expr::Array(_, pos), Expr::StringConstant(_, _)) => { + (Expr::Array(x), Expr::StringConstant(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for a string expects a string, not an array".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // #{...} in "xxxx" - (Expr::Map(_, pos), Expr::StringConstant(_, _)) => { + (Expr::Map(x), Expr::StringConstant(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for a string expects a string, not an object map".into(), ) - .into_err(*pos)) + .into_err(x.1)) } - // (??? = ???) in "xxxx", () in "xxxx" - (Expr::Assignment(_, _, pos), Expr::StringConstant(_, _)) - | (Expr::Unit(pos), Expr::StringConstant(_, _)) => { + // (??? = ???) in "xxxx" + (Expr::Assignment(x), Expr::StringConstant(_)) => { + return Err(PERR::MalformedInExpr( + "'in' expression for a string expects a string, not ()".into(), + ) + .into_err(x.2)) + } + // () in "xxxx" + (Expr::Unit(pos), Expr::StringConstant(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for a string expects a string, not ()".into(), ) @@ -1530,52 +1555,62 @@ fn make_in_expr(lhs: Expr, rhs: Expr, op_pos: Position) -> Result (), + (Expr::StringConstant(_), Expr::Map(_)) | (Expr::CharConstant(_), Expr::Map(_)) => (), // 123.456 in #{...} #[cfg(not(feature = "no_float"))] - (Expr::FloatConstant(_, pos), Expr::Map(_, _)) => { + (Expr::FloatConstant(x), Expr::Map(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for an object map expects a string, not a float".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // 123 in #{...} - (Expr::IntegerConstant(_, pos), Expr::Map(_, _)) => { + (Expr::IntegerConstant(x), Expr::Map(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for an object map expects a string, not a number".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // (??? && ???) in #{...}, (??? || ???) in #{...}, (??? in ???) in #{...}, + (Expr::And(x), Expr::Map(_)) + | (Expr::Or(x), Expr::Map(_)) + | (Expr::In(x), Expr::Map(_)) => { + return Err(PERR::MalformedInExpr( + "'in' expression for an object map expects a string, not a boolean".into(), + ) + .into_err(x.2)) + } // true in #{...}, false in #{...} - (Expr::And(_, _, pos), Expr::Map(_, _)) - | (Expr::Or(_, _, pos), Expr::Map(_, _)) - | (Expr::In(_, _, pos), Expr::Map(_, _)) - | (Expr::True(pos), Expr::Map(_, _)) - | (Expr::False(pos), Expr::Map(_, _)) => { + (Expr::True(pos), Expr::Map(_)) | (Expr::False(pos), Expr::Map(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for an object map expects a string, not a boolean".into(), ) .into_err(*pos)) } // [???, ???, ???] in #{..} - (Expr::Array(_, pos), Expr::Map(_, _)) => { + (Expr::Array(x), Expr::Map(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for an object map expects a string, not an array".into(), ) - .into_err(*pos)) + .into_err(x.1)) } // #{...} in #{..} - (Expr::Map(_, pos), Expr::Map(_, _)) => { + (Expr::Map(x), Expr::Map(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for an object map expects a string, not an object map".into(), ) - .into_err(*pos)) + .into_err(x.1)) } - // (??? = ???) in #{...}, () in #{...} - (Expr::Assignment(_, _, pos), Expr::Map(_, _)) | (Expr::Unit(pos), Expr::Map(_, _)) => { + // (??? = ???) in #{...} + (Expr::Assignment(x), Expr::Map(_)) => { + return Err(PERR::MalformedInExpr( + "'in' expression for an object map expects a string, not ()".into(), + ) + .into_err(x.2)) + } + // () in #{...} + (Expr::Unit(pos), Expr::Map(_)) => { return Err(PERR::MalformedInExpr( "'in' expression for an object map expects a string, not ()".into(), ) @@ -1585,7 +1620,7 @@ fn make_in_expr(lhs: Expr, rhs: Expr, op_pos: Position) -> Result (), } - Ok(Expr::In(Box::new(lhs), Box::new(rhs), op_pos)) + Ok(Expr::In(Box::new((lhs, rhs, op_pos)))) } /// Parse a binary expression. @@ -1630,155 +1665,59 @@ fn parse_binary_op<'a>( }; let cmp_default = Some(Box::new(false.into())); + let op = op_token.syntax(); + let hash = calc_fn_hash(empty(), &op, repeat(EMPTY_TYPE_ID()).take(2)); + let mut args = vec![current_lhs, rhs]; current_lhs = match op_token { - Token::Plus => Expr::FnCall( - Box::new("+".into()), - None, - calc_fn_hash(empty(), "+", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::Minus => Expr::FnCall( - Box::new("-".into()), - None, - calc_fn_hash(empty(), "-", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::Multiply => Expr::FnCall( - Box::new("*".into()), - None, - calc_fn_hash(empty(), "*", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::Divide => Expr::FnCall( - Box::new("/".into()), - None, - calc_fn_hash(empty(), "/", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), + Token::Plus => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::Minus => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::Multiply => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::Divide => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), - Token::LeftShift => Expr::FnCall( - Box::new("<<".into()), - None, - calc_fn_hash(empty(), "<<", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::RightShift => Expr::FnCall( - Box::new(">>".into()), - None, - calc_fn_hash(empty(), ">>", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::Modulo => Expr::FnCall( - Box::new("%".into()), - None, - calc_fn_hash(empty(), "%", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::PowerOf => Expr::FnCall( - Box::new("~".into()), - None, - calc_fn_hash(empty(), "~", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), + Token::LeftShift => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::RightShift => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::Modulo => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::PowerOf => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), // Comparison operators default to false when passed invalid operands - Token::EqualsTo => Expr::FnCall( - Box::new("==".into()), - None, - calc_fn_hash(empty(), "==", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - cmp_default, - pos, - ), - Token::NotEqualsTo => Expr::FnCall( - Box::new("!=".into()), - None, - calc_fn_hash(empty(), "!=", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - cmp_default, - pos, - ), - Token::LessThan => Expr::FnCall( - Box::new("<".into()), - None, - calc_fn_hash(empty(), "<", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - cmp_default, - pos, - ), - Token::LessThanEqualsTo => Expr::FnCall( - Box::new("<=".into()), - None, - calc_fn_hash(empty(), "<=", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - cmp_default, - pos, - ), - Token::GreaterThan => Expr::FnCall( - Box::new(">".into()), - None, - calc_fn_hash(empty(), ">", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - cmp_default, - pos, - ), - Token::GreaterThanEqualsTo => Expr::FnCall( - Box::new(">=".into()), - None, - calc_fn_hash(empty(), ">=", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - cmp_default, - pos, - ), + Token::EqualsTo => Expr::FnCall(Box::new((op, None, hash, args, cmp_default, pos))), + Token::NotEqualsTo => Expr::FnCall(Box::new((op, None, hash, args, cmp_default, pos))), + Token::LessThan => Expr::FnCall(Box::new((op, None, hash, args, cmp_default, pos))), + Token::LessThanEqualsTo => { + Expr::FnCall(Box::new((op, None, hash, args, cmp_default, pos))) + } + Token::GreaterThan => Expr::FnCall(Box::new((op, None, hash, args, cmp_default, pos))), + Token::GreaterThanEqualsTo => { + Expr::FnCall(Box::new((op, None, hash, args, cmp_default, pos))) + } - Token::Or => Expr::Or(Box::new(current_lhs), Box::new(rhs), pos), - Token::And => Expr::And(Box::new(current_lhs), Box::new(rhs), pos), - Token::Ampersand => Expr::FnCall( - Box::new("&".into()), - None, - calc_fn_hash(empty(), "&", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::Pipe => Expr::FnCall( - Box::new("|".into()), - None, - calc_fn_hash(empty(), "|", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), - Token::XOr => Expr::FnCall( - Box::new("^".into()), - None, - calc_fn_hash(empty(), "^", repeat(EMPTY_TYPE_ID()).take(2)), - Box::new(vec![current_lhs, rhs]), - None, - pos, - ), + Token::Or => { + let rhs = args.pop().unwrap(); + let current_lhs = args.pop().unwrap(); + Expr::Or(Box::new((current_lhs, rhs, pos))) + } + Token::And => { + let rhs = args.pop().unwrap(); + let current_lhs = args.pop().unwrap(); + Expr::And(Box::new((current_lhs, rhs, pos))) + } + Token::Ampersand => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::Pipe => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), + Token::XOr => Expr::FnCall(Box::new((op, None, hash, args, None, pos))), - Token::In => make_in_expr(current_lhs, rhs, pos)?, + Token::In => { + let rhs = args.pop().unwrap(); + let current_lhs = args.pop().unwrap(); + make_in_expr(current_lhs, rhs, pos)? + } #[cfg(not(feature = "no_object"))] - Token::Period => make_dot_expr(current_lhs, rhs, pos, false)?, + Token::Period => { + let rhs = args.pop().unwrap(); + let current_lhs = args.pop().unwrap(); + make_dot_expr(current_lhs, rhs, pos, false)? + } token => return Err(PERR::UnknownOperator(token.into()).into_err(pos)), }; @@ -1857,22 +1796,18 @@ fn parse_if<'a>( // if guard { if_body } else ... let else_body = if match_token(input, Token::Else).unwrap_or(false) { - Some(Box::new(if let (Token::If, _) = input.peek().unwrap() { + Some(if let (Token::If, _) = input.peek().unwrap() { // if guard { if_body } else if ... parse_if(input, stack, breakable, allow_stmt_expr)? } else { // if guard { if_body } else { else-body } parse_block(input, stack, breakable, allow_stmt_expr)? - })) + }) } else { None }; - Ok(Stmt::IfThenElse( - Box::new(guard), - Box::new(if_body), - else_body, - )) + Ok(Stmt::IfThenElse(Box::new((guard, if_body, else_body)))) } /// Parse a while loop. @@ -1890,7 +1825,7 @@ fn parse_while<'a>( ensure_not_assignment(input)?; let body = parse_block(input, stack, true, allow_stmt_expr)?; - Ok(Stmt::While(Box::new(guard), Box::new(body))) + Ok(Stmt::While(Box::new((guard, body)))) } /// Parse a loop statement. @@ -1952,7 +1887,7 @@ fn parse_for<'a>( stack.truncate(prev_len); - Ok(Stmt::For(Box::new(name), Box::new(expr), Box::new(body))) + Ok(Stmt::For(Box::new((name, expr, body)))) } /// Parse a variable definition statement. @@ -1981,12 +1916,12 @@ fn parse_let<'a>( // let name = expr ScopeEntryType::Normal => { stack.push((name.clone(), ScopeEntryType::Normal)); - Ok(Stmt::Let(Box::new(name), Some(Box::new(init_value)), pos)) + Ok(Stmt::Let(Box::new((name, Some(init_value), pos)))) } // const name = { expr:constant } ScopeEntryType::Constant if init_value.is_constant() => { stack.push((name.clone(), ScopeEntryType::Constant)); - Ok(Stmt::Const(Box::new(name), Box::new(init_value), pos)) + Ok(Stmt::Const(Box::new((name, init_value, pos)))) } // const name = expr - error ScopeEntryType::Constant => { @@ -2000,11 +1935,11 @@ fn parse_let<'a>( match var_type { ScopeEntryType::Normal => { stack.push((name.clone(), ScopeEntryType::Normal)); - Ok(Stmt::Let(Box::new(name), None, pos)) + Ok(Stmt::Let(Box::new((name, None, pos)))) } ScopeEntryType::Constant => { stack.push((name.clone(), ScopeEntryType::Constant)); - Ok(Stmt::Const(Box::new(name), Box::new(Expr::Unit(pos)), pos)) + Ok(Stmt::Const(Box::new((name, Expr::Unit(pos), pos)))) } // Variable cannot be a module ScopeEntryType::Module => unreachable!(), @@ -2043,7 +1978,7 @@ fn parse_import<'a>( }; stack.push((name.clone(), ScopeEntryType::Module)); - Ok(Stmt::Import(Box::new(expr), Box::new(name), pos)) + Ok(Stmt::Import(Box::new((expr, name, pos)))) } /// Parse an export statement. @@ -2100,7 +2035,7 @@ fn parse_export<'a>(input: &mut Peekable>) -> Result( stack.truncate(prev_len); - Ok(Stmt::Block(statements, pos)) + Ok(Stmt::Block(Box::new((statements, pos)))) } /// Parse an expression as a statement. @@ -2230,14 +2165,21 @@ fn parse_stmt<'a>( match input.peek().unwrap() { // `return`/`throw` at - (Token::EOF, pos) => Ok(Stmt::ReturnWithVal(None, return_type, *pos)), + (Token::EOF, pos) => Ok(Stmt::ReturnWithVal(Box::new((None, return_type, *pos)))), // `return;` or `throw;` - (Token::SemiColon, _) => Ok(Stmt::ReturnWithVal(None, return_type, pos)), + (Token::SemiColon, _) => { + Ok(Stmt::ReturnWithVal(Box::new((None, return_type, pos)))) + } // `return` or `throw` with expression (_, _) => { let expr = parse_expr(input, stack, allow_stmt_expr)?; let pos = expr.position(); - Ok(Stmt::ReturnWithVal(Some(Box::new(expr)), return_type, pos)) + + Ok(Stmt::ReturnWithVal(Box::new(( + Some(expr), + return_type, + pos, + )))) } } } @@ -2329,10 +2271,10 @@ fn parse_fn<'a>( })?; // Parse function body - let body = Box::new(match input.peek().unwrap() { + let body = match input.peek().unwrap() { (Token::LeftBrace, _) => parse_block(input, stack, false, allow_stmt_expr)?, (_, pos) => return Err(PERR::FnMissingBody(name).into_err(*pos)), - }); + }; let params = params.into_iter().map(|(p, _)| p).collect(); @@ -2477,10 +2419,13 @@ pub fn parse<'a>( /// Returns Some(expression) if conversion is successful. Otherwise None. pub fn map_dynamic_to_expr(value: Dynamic, pos: Position) -> Option { match value.0 { + #[cfg(not(feature = "no_float"))] + Union::Float(value) => Some(Expr::FloatConstant(Box::new((value, pos)))), + Union::Unit(_) => Some(Expr::Unit(pos)), - Union::Int(value) => Some(Expr::IntegerConstant(value, pos)), - Union::Char(value) => Some(Expr::CharConstant(value, pos)), - Union::Str(value) => Some(Expr::StringConstant((*value).clone(), pos)), + Union::Int(value) => Some(Expr::IntegerConstant(Box::new((value, pos)))), + Union::Char(value) => Some(Expr::CharConstant(Box::new((value, pos)))), + Union::Str(value) => Some(Expr::StringConstant(Box::new(((*value).clone(), pos)))), Union::Bool(true) => Some(Expr::True(pos)), Union::Bool(false) => Some(Expr::False(pos)), #[cfg(not(feature = "no_index"))] @@ -2491,10 +2436,10 @@ pub fn map_dynamic_to_expr(value: Dynamic, pos: Position) -> Option { .collect(); if items.iter().all(Option::is_some) { - Some(Expr::Array( + Some(Expr::Array(Box::new(( items.into_iter().map(Option::unwrap).collect(), pos, - )) + )))) } else { None } @@ -2506,19 +2451,17 @@ pub fn map_dynamic_to_expr(value: Dynamic, pos: Position) -> Option { .map(|(k, v)| (k, map_dynamic_to_expr(v, pos), pos)) .collect(); if items.iter().all(|(_, expr, _)| expr.is_some()) { - Some(Expr::Map( + Some(Expr::Map(Box::new(( items .into_iter() .map(|(k, expr, pos)| (k, expr.unwrap(), pos)) .collect(), pos, - )) + )))) } else { None } } - #[cfg(not(feature = "no_float"))] - Union::Float(value) => Some(Expr::FloatConstant(value, pos)), _ => None, } diff --git a/src/scope.rs b/src/scope.rs index 04e11fe6..542bb01b 100644 --- a/src/scope.rs +++ b/src/scope.rs @@ -7,7 +7,7 @@ use crate::token::Position; #[cfg(not(feature = "no_module"))] use crate::module::Module; -use crate::stdlib::{borrow::Cow, boxed::Box, iter, vec, vec::Vec}; +use crate::stdlib::{borrow::Cow, boxed::Box, iter, vec::Vec}; /// Type of an entry in the Scope. #[derive(Debug, Eq, PartialEq, Hash, Copy, Clone)] diff --git a/src/token.rs b/src/token.rs index 9692b112..25d26ff7 100644 --- a/src/token.rs +++ b/src/token.rs @@ -206,14 +206,14 @@ pub enum Token { impl Token { /// Get the syntax of the token. - pub fn syntax(&self) -> Cow { + pub fn syntax(&self) -> Cow<'static, str> { use Token::*; match self { IntegerConstant(i) => i.to_string().into(), #[cfg(not(feature = "no_float"))] FloatConstant(f) => f.to_string().into(), - Identifier(s) => s.into(), + Identifier(s) => s.clone().into(), CharConstant(c) => c.to_string().into(), LexError(err) => err.to_string().into(),