0264408
1855 lines
64 KiB
Rust
1855 lines
64 KiB
Rust
use crate::ast::*;
|
|
use crate::error::RuntimeError;
|
|
use crate::interpreter::Signal;
|
|
use super::{Value, Env, Function};
|
|
use std::collections::HashMap;
|
|
use std::rc::Rc;
|
|
use std::cell::RefCell;
|
|
|
|
pub struct Interpreter {
|
|
pub env: Rc<RefCell<Env>>,
|
|
}
|
|
|
|
impl Interpreter {
|
|
pub fn new() -> Self {
|
|
let env = Rc::new(RefCell::new(Env::new(None)));
|
|
super::builtins::register_all(&env);
|
|
Self { env }
|
|
}
|
|
|
|
pub fn interpret(&mut self, statements: Vec<Stmt>) -> Result<(), RuntimeError> {
|
|
for stmt in statements {
|
|
self.execute(stmt)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn execute(&mut self, stmt: Stmt) -> Result<Signal, RuntimeError> {
|
|
match stmt {
|
|
Stmt::Let { name, initializer, mutable } => {
|
|
let val = self.evaluate(initializer)?;
|
|
self.env.borrow_mut().define(name, val, mutable);
|
|
Ok(Signal::None)
|
|
}
|
|
Stmt::ExprStmt(expr) => {
|
|
self.evaluate(expr)?;
|
|
Ok(Signal::None)
|
|
}
|
|
Stmt::Block(stmts) => {
|
|
let previous = Rc::clone(&self.env);
|
|
self.env = Rc::new(RefCell::new(Env::new(Some(previous))));
|
|
let mut signal = Signal::None;
|
|
for s in stmts {
|
|
signal = self.execute(s)?;
|
|
if !matches!(signal, Signal::None) {
|
|
break;
|
|
}
|
|
}
|
|
let parent = self.env.borrow().parent.as_ref().unwrap().clone();
|
|
self.env = parent;
|
|
Ok(signal)
|
|
}
|
|
Stmt::If { condition, then_branch, else_branch } => {
|
|
let cond_val = self.evaluate(condition)?;
|
|
if self.is_truthy(&cond_val) {
|
|
self.execute(*then_branch)
|
|
} else if let Some(else_branch) = else_branch {
|
|
self.execute(*else_branch)
|
|
} else {
|
|
Ok(Signal::None)
|
|
}
|
|
}
|
|
Stmt::While { condition, body } => {
|
|
loop {
|
|
let cond_val = self.evaluate(condition.clone())?;
|
|
if !self.is_truthy(&cond_val) {
|
|
break;
|
|
}
|
|
match self.execute(*body.clone())? {
|
|
Signal::Break => break,
|
|
Signal::Continue => continue,
|
|
sig @ Signal::Return(_) => return Ok(sig),
|
|
Signal::None => {}
|
|
}
|
|
}
|
|
Ok(Signal::None)
|
|
}
|
|
Stmt::For { initializer, condition, step, body } => {
|
|
if let Some(init) = initializer {
|
|
self.execute(*init)?;
|
|
}
|
|
loop {
|
|
if let Some(cond) = &condition {
|
|
let cond_val = self.evaluate(cond.clone())?;
|
|
if !self.is_truthy(&cond_val) {
|
|
break;
|
|
}
|
|
}
|
|
match self.execute(*body.clone())? {
|
|
Signal::Break => break,
|
|
Signal::Continue => {
|
|
if let Some(step) = &step {
|
|
self.evaluate(step.clone())?;
|
|
}
|
|
continue;
|
|
}
|
|
sig @ Signal::Return(_) => return Ok(sig),
|
|
Signal::None => {}
|
|
}
|
|
if let Some(step) = &step {
|
|
self.evaluate(step.clone())?;
|
|
}
|
|
}
|
|
Ok(Signal::None)
|
|
}
|
|
Stmt::ForIn { var_name, iterable, body } => {
|
|
let iter_val = self.evaluate(iterable)?;
|
|
let items: Vec<Value> = match &iter_val {
|
|
Value::Array(arr) => arr.borrow().clone(),
|
|
Value::Object(obj) => obj.borrow().keys().map(|k| Value::String(k.clone())).collect(),
|
|
Value::String(s) => s.chars().map(|c| Value::String(c.to_string())).collect(),
|
|
_ => {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: "for-in requires an array, object, or string".into(),
|
|
token: None,
|
|
});
|
|
}
|
|
};
|
|
|
|
let mut signal = Signal::None;
|
|
for item in items {
|
|
// Create a new scope for each iteration so the loop variable
|
|
// is isolated and break/continue clean up correctly.
|
|
let previous = Rc::clone(&self.env);
|
|
self.env = Rc::new(RefCell::new(Env::new(Some(previous))));
|
|
self.env.borrow_mut().define(var_name.clone(), item, true);
|
|
|
|
signal = self.execute(*body.clone())?;
|
|
// Restore parent scope before checking signal
|
|
let parent = self.env.borrow().parent.as_ref().unwrap().clone();
|
|
self.env = parent;
|
|
|
|
match signal {
|
|
Signal::Break => { signal = Signal::None; break; }
|
|
Signal::Continue => { signal = Signal::None; continue; }
|
|
sig @ Signal::Return(_) => return Ok(sig),
|
|
Signal::None => {}
|
|
}
|
|
}
|
|
Ok(signal)
|
|
}
|
|
Stmt::Function { name, params, body } => {
|
|
let func = Value::Function(Rc::new(Function {
|
|
params,
|
|
body,
|
|
env: Rc::clone(&self.env),
|
|
name: Some(name.clone()),
|
|
}));
|
|
self.env.borrow_mut().define(name, func, true);
|
|
Ok(Signal::None)
|
|
}
|
|
Stmt::Return(expr_opt) => {
|
|
if let Some(expr) = expr_opt {
|
|
Ok(Signal::Return(self.evaluate(expr)?))
|
|
} else {
|
|
Ok(Signal::Return(Value::Nil))
|
|
}
|
|
}
|
|
Stmt::Break => Ok(Signal::Break),
|
|
Stmt::Continue => Ok(Signal::Continue),
|
|
}
|
|
}
|
|
|
|
fn evaluate(&mut self, expr: Expr) -> Result<Value, RuntimeError> {
|
|
match expr {
|
|
Expr::Literal(lit) => Ok(match lit {
|
|
crate::ast::expr::Literal::Number(n) => Value::Number(n),
|
|
crate::ast::expr::Literal::String(s) => Value::String(s),
|
|
crate::ast::expr::Literal::Bool(b) => Value::Bool(b),
|
|
crate::ast::expr::Literal::Nil => Value::Nil,
|
|
}),
|
|
Expr::Variable(name) => {
|
|
match self.env.borrow().get(&name) {
|
|
Some(val) => Ok(val),
|
|
None => Err(RuntimeError::RuntimeError {
|
|
message: format!("Undefined variable '{}'", name),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
Expr::Assign { name, op, value } => {
|
|
let rhs = self.evaluate(*value)?;
|
|
let val = match op {
|
|
AssignOp::Equal => rhs,
|
|
_ => {
|
|
let current = self.env.borrow().get(&name).ok_or_else(|| RuntimeError::RuntimeError { message: format!("Undefined variable '{}'", name), token: None })?;
|
|
self.apply_assign_op(current.clone(), rhs, op)?
|
|
}
|
|
};
|
|
match self.env.borrow_mut().assign(&name, val.clone()) {
|
|
Ok(true) => {}
|
|
Ok(false) => {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: format!("Undefined variable '{}'", name),
|
|
token: None,
|
|
});
|
|
}
|
|
Err(msg) => {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: msg,
|
|
token: None,
|
|
});
|
|
}
|
|
}
|
|
Ok(val)
|
|
}
|
|
Expr::Get { object, name } => {
|
|
let obj = self.evaluate(*object)?;
|
|
match obj {
|
|
Value::Object(map) => {
|
|
match map.borrow().get(&name) {
|
|
Some(val) => Ok(val.clone()),
|
|
None => Err(RuntimeError::RuntimeError {
|
|
message: format!("Undefined property '{}'", name),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Only objects have properties".to_string(),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
Expr::Set { object, name, op, value } => {
|
|
let obj = self.evaluate(*object)?;
|
|
let rhs = self.evaluate(*value)?;
|
|
match obj {
|
|
Value::Object(map) => {
|
|
let val = match op {
|
|
AssignOp::Equal => rhs,
|
|
_ => {
|
|
let map_borrow = map.borrow();
|
|
let current = map_borrow.get(&name).ok_or_else(|| RuntimeError::RuntimeError { message: format!("Property '{}' does not exist", name), token: None })?;
|
|
self.apply_assign_op(current.clone(), rhs, op)?
|
|
}
|
|
};
|
|
map.borrow_mut().insert(name, val.clone());
|
|
Ok(val)
|
|
}
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Only objects have properties".to_string(),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
Expr::IndexGet { array, index } => {
|
|
let target = self.evaluate(*array)?;
|
|
let idx_val = self.evaluate(*index)?;
|
|
// Object index access: obj["key"]
|
|
if let Value::Object(map) = &target {
|
|
let key = match &idx_val {
|
|
Value::String(s) => s.clone(),
|
|
_ => return Err(RuntimeError::RuntimeError {
|
|
message: "Object index must be a string".into(),
|
|
token: None,
|
|
}),
|
|
};
|
|
return map.borrow().get(&key).cloned().ok_or_else(|| RuntimeError::RuntimeError {
|
|
message: format!("Undefined property '{}'", key),
|
|
token: None,
|
|
});
|
|
}
|
|
let i = self.as_array_index(&idx_val)?;
|
|
match target {
|
|
Value::Array(vec) => {
|
|
let vec = vec.borrow();
|
|
vec.get(i).cloned().ok_or_else(|| RuntimeError::RuntimeError {
|
|
message: format!("Index {} out of bounds (len {})", i, vec.len()),
|
|
token: None,
|
|
})
|
|
}
|
|
Value::String(s) => {
|
|
let chars: Vec<char> = s.chars().collect();
|
|
chars.get(i).map(|&c| Value::String(c.to_string())).ok_or_else(|| RuntimeError::RuntimeError {
|
|
message: format!("Index {} out of bounds (len {})", i, chars.len()),
|
|
token: None,
|
|
})
|
|
}
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Index access on non-array, non-string, non-object value".to_string(),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
Expr::IndexSet { array, index, op, value } => {
|
|
let target = self.evaluate(*array)?;
|
|
let idx_val = self.evaluate(*index)?;
|
|
let rhs = self.evaluate(*value)?;
|
|
// Object index assignment: obj["key"] = value
|
|
if let Value::Object(map) = &target {
|
|
let key = match &idx_val {
|
|
Value::String(s) => s.clone(),
|
|
_ => return Err(RuntimeError::RuntimeError {
|
|
message: "Object index must be a string".into(),
|
|
token: None,
|
|
}),
|
|
};
|
|
let val = match op {
|
|
AssignOp::Equal => rhs,
|
|
_ => {
|
|
let map_borrow = map.borrow();
|
|
let current = map_borrow.get(&key).ok_or_else(|| RuntimeError::RuntimeError {
|
|
message: format!("Property '{}' does not exist", key),
|
|
token: None,
|
|
})?;
|
|
self.apply_assign_op(current.clone(), rhs, op)?
|
|
}
|
|
};
|
|
map.borrow_mut().insert(key, val.clone());
|
|
return Ok(val);
|
|
}
|
|
let i = self.as_array_index(&idx_val)?;
|
|
match target {
|
|
Value::Array(vec) => {
|
|
let mut vec = vec.borrow_mut();
|
|
if i >= vec.len() {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: format!("Index {} out of bounds (len {})", i, vec.len()),
|
|
token: None,
|
|
});
|
|
}
|
|
let val = match op {
|
|
AssignOp::Equal => rhs,
|
|
_ => {
|
|
let current = vec[i].clone();
|
|
self.apply_assign_op(current, rhs, op)?
|
|
}
|
|
};
|
|
vec[i] = val.clone();
|
|
Ok(val)
|
|
}
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Index assignment on non-array, non-object value".to_string(),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
Expr::ObjectLiteral { properties } => {
|
|
let mut map = HashMap::new();
|
|
for (key, value_expr) in properties {
|
|
let value = self.evaluate(value_expr)?;
|
|
map.insert(key, value);
|
|
}
|
|
Ok(Value::Object(Rc::new(RefCell::new(map))))
|
|
}
|
|
Expr::ArrayLiteral { elements } => {
|
|
let mut arr = Vec::new();
|
|
for e in elements {
|
|
arr.push(self.evaluate(e)?);
|
|
}
|
|
Ok(Value::Array(Rc::new(RefCell::new(arr))))
|
|
}
|
|
Expr::Unary { op, right } => {
|
|
let val = self.evaluate(*right)?;
|
|
match op {
|
|
crate::ast::expr::UnaryOp::Negate => match val {
|
|
Value::Number(n) => Ok(Value::Number(-n)),
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Unary '-' on non-number".to_string(),
|
|
token: None,
|
|
}),
|
|
},
|
|
crate::ast::expr::UnaryOp::Not => Ok(Value::Bool(!self.is_truthy(&val))),
|
|
}
|
|
}
|
|
Expr::Binary { left, op, right } => {
|
|
let l = self.evaluate(*left)?;
|
|
let r = self.evaluate(*right)?;
|
|
match op {
|
|
crate::ast::expr::BinaryOp::Add => {
|
|
// If either operand is a string, coerce both to string and concatenate.
|
|
if matches!(l, Value::String(_)) || matches!(r, Value::String(_)) {
|
|
Ok(Value::String(format!("{}{}", l, r)))
|
|
} else {
|
|
match (l, r) {
|
|
(Value::Number(a), Value::Number(b)) => Ok(Value::Number(a+b)),
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Invalid '+' operands".to_string(),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
}
|
|
crate::ast::expr::BinaryOp::Sub => match (l,r) {
|
|
(Value::Number(a), Value::Number(b)) => Ok(Value::Number(a-b)),
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Invalid '-' operands".to_string(),
|
|
token: None,
|
|
}),
|
|
},
|
|
crate::ast::expr::BinaryOp::Mul => match (l,r) {
|
|
(Value::Number(a), Value::Number(b)) => Ok(Value::Number(a*b)),
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Invalid '*' operands".to_string(),
|
|
token: None,
|
|
}),
|
|
},
|
|
crate::ast::expr::BinaryOp::Div => match (l,r) {
|
|
(Value::Number(_), Value::Number(b)) if b == 0.0 => {
|
|
Err(RuntimeError::RuntimeError {
|
|
message: "Division by zero".to_string(),
|
|
token: None,
|
|
})
|
|
}
|
|
(Value::Number(a), Value::Number(b)) => Ok(Value::Number(a/b)),
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Invalid '/' operands".to_string(),
|
|
token: None,
|
|
}),
|
|
},
|
|
crate::ast::expr::BinaryOp::Mod => match (l,r) {
|
|
(Value::Number(_), Value::Number(b)) if b == 0.0 => {
|
|
Err(RuntimeError::RuntimeError {
|
|
message: "Modulo by zero".to_string(),
|
|
token: None,
|
|
})
|
|
}
|
|
(Value::Number(a), Value::Number(b)) => Ok(Value::Number(a%b)),
|
|
_ => Err(RuntimeError::RuntimeError {
|
|
message: "Invalid '%' operands".to_string(),
|
|
token: None,
|
|
}),
|
|
},
|
|
crate::ast::expr::BinaryOp::Greater => Ok(Value::Bool(self.as_number(&l)? > self.as_number(&r)?)),
|
|
crate::ast::expr::BinaryOp::GreaterEqual => Ok(Value::Bool(self.as_number(&l)? >= self.as_number(&r)?)),
|
|
crate::ast::expr::BinaryOp::Less => Ok(Value::Bool(self.as_number(&l)? < self.as_number(&r)?)),
|
|
crate::ast::expr::BinaryOp::LessEqual => Ok(Value::Bool(self.as_number(&l)? <= self.as_number(&r)?)),
|
|
crate::ast::expr::BinaryOp::Equal => Ok(Value::Bool(self.is_equal(&l,&r))),
|
|
crate::ast::expr::BinaryOp::NotEqual => Ok(Value::Bool(!self.is_equal(&l,&r))),
|
|
}
|
|
}
|
|
Expr::Logical { left, op, right } => {
|
|
let l = self.evaluate(*left)?;
|
|
match op {
|
|
crate::ast::expr::LogicalOp::And => {
|
|
Ok(if !self.is_truthy(&l) { l } else { self.evaluate(*right)? })
|
|
}
|
|
crate::ast::expr::LogicalOp::Or => {
|
|
Ok(if self.is_truthy(&l) { l } else { self.evaluate(*right)? })
|
|
}
|
|
}
|
|
}
|
|
Expr::Ternary { condition, then_branch, else_branch } => {
|
|
let cond = self.evaluate(*condition)?;
|
|
if self.is_truthy(&cond) {
|
|
self.evaluate(*then_branch)
|
|
} else {
|
|
self.evaluate(*else_branch)
|
|
}
|
|
}
|
|
Expr::Call { callee, arguments } => {
|
|
let func = self.evaluate(*callee)?;
|
|
let mut args = Vec::new();
|
|
for e in arguments {
|
|
args.push(self.evaluate(e)?);
|
|
}
|
|
self.call_function(func, args)
|
|
}
|
|
Expr::Lambda { params, body } => {
|
|
Ok(Value::Function(Rc::new(Function {
|
|
params,
|
|
body,
|
|
env: Rc::clone(&self.env),
|
|
name: None,
|
|
})))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn call_function(&mut self, func_val: Value, args: Vec<Value>) -> Result<Value, RuntimeError> {
|
|
match func_val {
|
|
Value::NativeFunction(native_fn) => {
|
|
native_fn(args)
|
|
}
|
|
Value::Function(f) => {
|
|
let env = Rc::new(RefCell::new(Env::new(Some(Rc::clone(&f.env)))));
|
|
|
|
if let Some(name) = &f.name {
|
|
env.borrow_mut().define(name.clone(), Value::Function(Rc::clone(&f)), true);
|
|
}
|
|
|
|
for (i,param) in f.params.iter().enumerate() {
|
|
let val = args.get(i).cloned().unwrap_or(Value::Nil);
|
|
env.borrow_mut().define(param.clone(), val, true);
|
|
}
|
|
|
|
let previous = Rc::clone(&self.env);
|
|
self.env = env;
|
|
let mut ret = Value::Nil;
|
|
for stmt in &f.body {
|
|
match self.execute(stmt.clone())? {
|
|
Signal::Return(val) => { ret = val; break; }
|
|
Signal::None => {}
|
|
Signal::Break | Signal::Continue => {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: "break/continue outside of loop".to_string(),
|
|
token: None,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
self.env = previous;
|
|
Ok(ret)
|
|
}
|
|
_ => {
|
|
Err(RuntimeError::RuntimeError {
|
|
message: "Attempt to call non-function".to_string(),
|
|
token: None,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
fn is_truthy(&self, val: &Value) -> bool {
|
|
match val {
|
|
Value::Nil => false,
|
|
Value::Bool(b) => *b,
|
|
_ => true,
|
|
}
|
|
}
|
|
|
|
fn is_equal(&self, a: &Value, b: &Value) -> bool {
|
|
match (a,b) {
|
|
(Value::Nil, Value::Nil) => true,
|
|
(Value::Bool(x), Value::Bool(y)) => x==y,
|
|
(Value::Number(x), Value::Number(y)) => x==y,
|
|
(Value::String(x), Value::String(y)) => x==y,
|
|
(Value::Array(x), Value::Array(y)) => {
|
|
let x = x.borrow();
|
|
let y = y.borrow();
|
|
if x.len() != y.len() { return false; }
|
|
x.iter().zip(y.iter()).all(|(a,b)| self.is_equal(a,b))
|
|
}
|
|
(Value::Object(x), Value::Object(y)) => {
|
|
let x = x.borrow();
|
|
let y = y.borrow();
|
|
if x.len() != y.len() { return false; }
|
|
x.iter().all(|(k, v)| {
|
|
y.get(k).map_or(false, |yv| self.is_equal(v, yv))
|
|
})
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn apply_assign_op(&self, left: Value, right: Value, op: AssignOp) -> Result<Value, RuntimeError> {
|
|
match op {
|
|
AssignOp::Equal => Ok(right),
|
|
AssignOp::PlusEqual => {
|
|
if let Value::String(s) = &left {
|
|
Ok(Value::String(format!("{}{}", s, right)))
|
|
} else {
|
|
let left_num = self.as_number(&left)?;
|
|
let right_num = self.as_number(&right)?;
|
|
Ok(Value::Number(left_num + right_num))
|
|
}
|
|
}
|
|
AssignOp::MinusEqual => {
|
|
let left_num = self.as_number(&left)?;
|
|
let right_num = self.as_number(&right)?;
|
|
Ok(Value::Number(left_num - right_num))
|
|
}
|
|
AssignOp::StarEqual => {
|
|
let left_num = self.as_number(&left)?;
|
|
let right_num = self.as_number(&right)?;
|
|
Ok(Value::Number(left_num * right_num))
|
|
}
|
|
AssignOp::SlashEqual => {
|
|
let left_num = self.as_number(&left)?;
|
|
let right_num = self.as_number(&right)?;
|
|
Ok(Value::Number(left_num / right_num))
|
|
}
|
|
AssignOp::PercentEqual => {
|
|
let left_num = self.as_number(&left)?;
|
|
let right_num = self.as_number(&right)?;
|
|
Ok(Value::Number(left_num % right_num))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn as_number(&self, val: &Value) -> Result<f64, RuntimeError> {
|
|
if let Value::Number(n) = val {
|
|
Ok(*n)
|
|
} else {
|
|
Err(RuntimeError::RuntimeError {
|
|
message: "Expected number".to_string(),
|
|
token: None,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn as_array_index(&self, val: &Value) -> Result<usize, RuntimeError> {
|
|
if let Value::Number(n) = val {
|
|
if *n < 0.0 || n.fract() != 0.0 {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: format!("Index must be a non-negative integer, got {}", n),
|
|
token: None,
|
|
});
|
|
}
|
|
Ok(*n as usize)
|
|
} else {
|
|
Err(RuntimeError::RuntimeError {
|
|
message: "Index must be a number".to_string(),
|
|
token: None,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests
|
|
// ============================================================================
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::lexer::Lexer;
|
|
use crate::parser::Parser;
|
|
|
|
/// Full pipeline: source → tokens → ast → interpret → last expression value.
|
|
/// Wraps in `let __result = <expr>;` so we can read the value back.
|
|
fn eval_expr(input: &str) -> Value {
|
|
let wrapped = format!("let __result = {};", input);
|
|
let (tokens, _) = Lexer::new(&wrapped).tokenize();
|
|
let mut parser = Parser::new(tokens);
|
|
let (stmts, errors) = parser.parse();
|
|
assert!(errors.is_empty(), "Parse errors: {:?}", errors);
|
|
let mut interpreter = Interpreter::new();
|
|
interpreter.interpret(stmts).expect("Runtime error");
|
|
interpreter.env.borrow().get("__result").expect("No __result in env")
|
|
}
|
|
|
|
/// Full pipeline for multiple statements. Returns the interpreter for env inspection.
|
|
fn run(input: &str) -> Interpreter {
|
|
let (tokens, _) = Lexer::new(input).tokenize();
|
|
let mut parser = Parser::new(tokens);
|
|
let (stmts, errors) = parser.parse();
|
|
assert!(errors.is_empty(), "Parse errors: {:?}", errors);
|
|
let mut interpreter = Interpreter::new();
|
|
interpreter.interpret(stmts).expect("Runtime error");
|
|
interpreter
|
|
}
|
|
|
|
/// Helper: get a variable from the interpreter's environment.
|
|
fn get_var(interp: &Interpreter, name: &str) -> Value {
|
|
interp.env.borrow().get(name).unwrap_or(Value::Nil)
|
|
}
|
|
|
|
/// Helper: assert a number value.
|
|
fn assert_num(val: &Value, expected: f64) {
|
|
match val {
|
|
Value::Number(n) => assert!((n - expected).abs() < f64::EPSILON,
|
|
"Expected {}, got {}", expected, n),
|
|
_ => panic!("Expected Number({}), got {:?}", expected, val),
|
|
}
|
|
}
|
|
|
|
/// Helper: assert a bool value.
|
|
fn assert_bool(val: &Value, expected: bool) {
|
|
match val {
|
|
Value::Bool(b) => assert_eq!(*b, expected),
|
|
_ => panic!("Expected Bool({}), got {:?}", expected, val),
|
|
}
|
|
}
|
|
|
|
/// Helper: assert nil.
|
|
fn assert_nil(val: &Value) {
|
|
match val {
|
|
Value::Nil => {}
|
|
_ => panic!("Expected Nil, got {:?}", val),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Literals
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_number() {
|
|
assert_num(&eval_expr("42"), 42.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_string() {
|
|
match eval_expr("\"hello\"") {
|
|
Value::String(s) => assert_eq!(s, "hello"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_true() {
|
|
assert_bool(&eval_expr("true"), true);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_false() {
|
|
assert_bool(&eval_expr("false"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_nil() {
|
|
assert_nil(&eval_expr("nil"));
|
|
}
|
|
|
|
// =========================================================================
|
|
// Arithmetic
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_add() {
|
|
assert_num(&eval_expr("1 + 2"), 3.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_sub() {
|
|
assert_num(&eval_expr("5 - 3"), 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_mul() {
|
|
assert_num(&eval_expr("4 * 3"), 12.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_div() {
|
|
assert_num(&eval_expr("10 / 4"), 2.5);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_mod() {
|
|
assert_num(&eval_expr("7 % 3"), 1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_complex_arithmetic() {
|
|
assert_num(&eval_expr("1 + 2 * 3"), 7.0);
|
|
assert_num(&eval_expr("(1 + 2) * 3"), 9.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// String concatenation
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_string_concat() {
|
|
match eval_expr("\"hello \" + \"world\"") {
|
|
Value::String(s) => assert_eq!(s, "hello world"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_string_plus_number() {
|
|
match eval_expr("\"a\" + 42") {
|
|
Value::String(s) => assert_eq!(s, "a42"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_number_plus_string() {
|
|
match eval_expr("42 + \"a\"") {
|
|
Value::String(s) => assert_eq!(s, "42a"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_string_plus_bool() {
|
|
match eval_expr("\"t\" + true") {
|
|
Value::String(s) => assert_eq!(s, "ttrue"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_bool_plus_string() {
|
|
match eval_expr("false + \"x\"") {
|
|
Value::String(s) => assert_eq!(s, "falsex"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_string_plus_nil() {
|
|
match eval_expr("\"x\" + nil") {
|
|
Value::String(s) => assert_eq!(s, "xnil"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_plusequal_string_concat() {
|
|
let interp = run("let s = \"hello\"; s += \" world\"; s += 42;");
|
|
match get_var(&interp, "s") {
|
|
Value::String(s) => assert_eq!(s, "hello world42"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Comparison
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_equal_numbers() {
|
|
assert_bool(&eval_expr("1 == 1"), true);
|
|
assert_bool(&eval_expr("1 == 2"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_not_equal() {
|
|
assert_bool(&eval_expr("1 != 2"), true);
|
|
assert_bool(&eval_expr("1 != 1"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_greater_less() {
|
|
assert_bool(&eval_expr("5 > 3"), true);
|
|
assert_bool(&eval_expr("3 > 5"), false);
|
|
assert_bool(&eval_expr("5 >= 5"), true);
|
|
assert_bool(&eval_expr("3 < 5"), true);
|
|
assert_bool(&eval_expr("5 < 3"), false);
|
|
assert_bool(&eval_expr("3 <= 3"), true);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_equal_strings() {
|
|
assert_bool(&eval_expr("\"a\" == \"a\""), true);
|
|
assert_bool(&eval_expr("\"a\" == \"b\""), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_equal_bools() {
|
|
assert_bool(&eval_expr("true == true"), true);
|
|
assert_bool(&eval_expr("true == false"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_nil_equals_nil() {
|
|
assert_bool(&eval_expr("nil == nil"), true);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Logical operators
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_logical_and_short_circuit() {
|
|
assert_bool(&eval_expr("true && true"), true);
|
|
assert_bool(&eval_expr("true && false"), false);
|
|
assert_bool(&eval_expr("false && true"), false);
|
|
// Short-circuit: false && <anything> returns false (the left value)
|
|
match eval_expr("false && 999") {
|
|
Value::Bool(false) => {}
|
|
v => panic!("Expected Bool(false), got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_logical_or_short_circuit() {
|
|
assert_bool(&eval_expr("true || false"), true);
|
|
assert_bool(&eval_expr("false || true"), true);
|
|
assert_bool(&eval_expr("false || false"), false);
|
|
// Short-circuit: true || <anything> returns true (the left value)
|
|
match eval_expr("true || 999") {
|
|
Value::Bool(true) => {}
|
|
v => panic!("Expected Bool(true), got {:?}", v),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Ternary
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_ternary_true_condition() {
|
|
assert_num(&eval_expr("true ? 1 : 2"), 1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_false_condition() {
|
|
assert_num(&eval_expr("false ? 1 : 2"), 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_truthy_condition() {
|
|
// Non-nil, non-false values are truthy
|
|
assert_num(&eval_expr("1 ? 42 : 99"), 42.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_nil_condition() {
|
|
assert_num(&eval_expr("nil ? 1 : 2"), 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_nested() {
|
|
let interp = run("let x = 5; let r = x > 3 ? (x > 10 ? 100 : 50) : 0;");
|
|
assert_num(&get_var(&interp, "r"), 50.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_with_computed_branches() {
|
|
let interp = run("let x = 10; let r = x > 5 ? x * 2 : x / 2;");
|
|
assert_num(&get_var(&interp, "r"), 20.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_short_circuit_then() {
|
|
// When condition is false, then_branch is not evaluated
|
|
let interp = run("let x = 0; let r = false ? (x = 999) : (x = 42);");
|
|
assert_num(&get_var(&interp, "x"), 42.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_ternary_short_circuit_else() {
|
|
// When condition is true, else_branch is not evaluated
|
|
let interp = run("let x = 0; let r = true ? (x = 42) : (x = 999);");
|
|
assert_num(&get_var(&interp, "x"), 42.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Unary
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_negation() {
|
|
assert_num(&eval_expr("-5"), -5.0);
|
|
assert_num(&eval_expr("--5"), 5.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_not() {
|
|
assert_bool(&eval_expr("!true"), false);
|
|
assert_bool(&eval_expr("!false"), true);
|
|
assert_bool(&eval_expr("!nil"), true);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Assignment and variables
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_variable_definition_and_use() {
|
|
let interp = run("let x = 10;");
|
|
assert_num(&get_var(&interp, "x"), 10.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_simple_assignment() {
|
|
let interp = run("let x = 5; x = 10;");
|
|
assert_num(&get_var(&interp, "x"), 10.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_compound_plus_equal() {
|
|
let interp = run("let x = 5; x += 3;");
|
|
assert_num(&get_var(&interp, "x"), 8.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_compound_minus_equal() {
|
|
let interp = run("let x = 10; x -= 3;");
|
|
assert_num(&get_var(&interp, "x"), 7.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_compound_star_equal() {
|
|
let interp = run("let x = 4; x *= 3;");
|
|
assert_num(&get_var(&interp, "x"), 12.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_compound_slash_equal() {
|
|
let interp = run("let x = 10; x /= 2;");
|
|
assert_num(&get_var(&interp, "x"), 5.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_compound_percent_equal() {
|
|
let interp = run("let x = 7; x %= 3;");
|
|
assert_num(&get_var(&interp, "x"), 1.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Const
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_const_definition() {
|
|
let interp = run("const x = 42;");
|
|
assert_num(&get_var(&interp, "x"), 42.0);
|
|
}
|
|
|
|
#[test]
|
|
fn error_const_reassignment() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
run("const x = 5; x = 10;");
|
|
});
|
|
assert!(result.is_err(), "Expected error for reassigning const");
|
|
}
|
|
|
|
#[test]
|
|
fn error_const_compound_assignment() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
run("const x = 5; x += 1;");
|
|
});
|
|
assert!(result.is_err(), "Expected error for compound assignment to const");
|
|
}
|
|
|
|
#[test]
|
|
fn eval_const_shadowing() {
|
|
// Inner block can shadow outer const with its own binding
|
|
let interp = run("const x = 10; { let x = 20; }");
|
|
assert_num(&get_var(&interp, "x"), 10.0); // Outer unchanged
|
|
}
|
|
|
|
#[test]
|
|
fn eval_const_object_mutation() {
|
|
// const prevents rebinding, not property mutation
|
|
let interp = run("const obj = { a: 1 }; obj.a = 2;");
|
|
match get_var(&interp, "obj") {
|
|
Value::Object(obj) => {
|
|
let obj = obj.borrow();
|
|
assert_num(obj.get("a").unwrap(), 2.0);
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_const_array_mutation() {
|
|
// const prevents rebinding, not index mutation
|
|
let interp = run("const arr = [1, 2]; arr[0] = 99;");
|
|
match get_var(&interp, "arr") {
|
|
Value::Array(arr) => {
|
|
assert_num(&arr.borrow()[0], 99.0);
|
|
}
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Scope
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_block_scope_isolation() {
|
|
let interp = run("{ let x = 42; }");
|
|
let val = get_var(&interp, "x");
|
|
assert_nil(&val); // x should not exist outside the block
|
|
}
|
|
|
|
#[test]
|
|
fn eval_block_can_access_outer() {
|
|
let interp = run("let x = 10; { let y = x + 1; }");
|
|
assert_num(&get_var(&interp, "x"), 10.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_shadowing() {
|
|
let interp = run("let x = 10; { let x = 20; }");
|
|
assert_num(&get_var(&interp, "x"), 10.0); // Outer x unchanged
|
|
}
|
|
|
|
#[test]
|
|
fn eval_assign_outer_from_inner() {
|
|
let interp = run("let x = 10; { x = 20; }");
|
|
assert_num(&get_var(&interp, "x"), 20.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Control flow: if
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_if_true_branch() {
|
|
let interp = run("let x = 0; if (true) { x = 1; }");
|
|
assert_num(&get_var(&interp, "x"), 1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_if_false_branch_skipped() {
|
|
let interp = run("let x = 0; if (false) { x = 1; }");
|
|
assert_num(&get_var(&interp, "x"), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_if_else_true() {
|
|
let interp = run("let x = 0; if (true) { x = 1; } else { x = 2; }");
|
|
assert_num(&get_var(&interp, "x"), 1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_if_else_false() {
|
|
let interp = run("let x = 0; if (false) { x = 1; } else { x = 2; }");
|
|
assert_num(&get_var(&interp, "x"), 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_if_truthy() {
|
|
// Non-nil, non-false values are truthy
|
|
let interp = run("let x = 0; if (1) { x = 42; }");
|
|
assert_num(&get_var(&interp, "x"), 42.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Control flow: while
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_while_loop() {
|
|
let interp = run("let i = 0; while (i < 5) { i = i + 1; }");
|
|
assert_num(&get_var(&interp, "i"), 5.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_while_never_runs() {
|
|
let interp = run("let x = 0; while (false) { x = 1; }");
|
|
assert_num(&get_var(&interp, "x"), 0.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Control flow: for
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_for_loop() {
|
|
let interp = run("let sum = 0; for (let i = 0; i < 5; i = i + 1) { sum = sum + i; }");
|
|
assert_num(&get_var(&interp, "sum"), 10.0); // 0+1+2+3+4
|
|
}
|
|
|
|
#[test]
|
|
fn eval_for_empty_clauses() {
|
|
// Infinite loop with break — just test it parses and doesn't crash on one iter
|
|
let interp = run("let x = 0; for (;;) { x = 1; break; }");
|
|
assert_num(&get_var(&interp, "x"), 1.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Control flow: break / continue
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_break() {
|
|
let interp = run("let i = 0; while (i < 100) { if (i == 5) { break; } i = i + 1; }");
|
|
assert_num(&get_var(&interp, "i"), 5.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_continue() {
|
|
let interp = run("let sum = 0; let j = 0; while (j < 5) { j = j + 1; if (j == 3) { continue; } sum = sum + j; }");
|
|
assert_num(&get_var(&interp, "sum"), 12.0); // 1+2+4+5 = 12 (skips 3)
|
|
}
|
|
|
|
#[test]
|
|
fn eval_break_in_for() {
|
|
let interp = run("let found = -1; for (let k = 0; k < 100; k = k + 1) { if (k * k > 50) { found = k; break; } }");
|
|
assert_num(&get_var(&interp, "found"), 8.0); // 8*8=64 > 50
|
|
}
|
|
|
|
// =========================================================================
|
|
// Functions
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_function_call() {
|
|
let interp = run("fn add(a, b) { return a + b; } let result = add(3, 4);");
|
|
assert_num(&get_var(&interp, "result"), 7.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_function_no_return() {
|
|
let interp = run("fn foo() { 42; } let result = foo();");
|
|
assert_nil(&get_var(&interp, "result")); // No explicit return → nil
|
|
}
|
|
|
|
#[test]
|
|
fn eval_recursion() {
|
|
let interp = run("fn fib(n) { if (n <= 1) { return n; } return fib(n-1) + fib(n-2); } let f = fib(10);");
|
|
assert_num(&get_var(&interp, "f"), 55.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_nested_function_calls() {
|
|
let interp = run("fn double(x) { return x * 2; } let r = double(double(3));");
|
|
assert_num(&get_var(&interp, "r"), 12.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Closures
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_simple_closure() {
|
|
let interp = run("
|
|
fn make_adder(x) { return fn(y) { return x + y; }; }
|
|
let add10 = make_adder(10);
|
|
let r = add10(5);
|
|
");
|
|
assert_num(&get_var(&interp, "r"), 15.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_closure_captures_by_value_semantics() {
|
|
// Each call to make_adder creates an independent closure
|
|
let interp = run("
|
|
fn make_adder(x) { return fn(y) { return x + y; }; }
|
|
let add5 = make_adder(5);
|
|
let add10 = make_adder(10);
|
|
let r1 = add5(0);
|
|
let r2 = add10(0);
|
|
");
|
|
assert_num(&get_var(&interp, "r1"), 5.0);
|
|
assert_num(&get_var(&interp, "r2"), 10.0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Arrays
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_array_creation() {
|
|
match eval_expr("[1, 2, 3]") {
|
|
Value::Array(arr) => {
|
|
let arr = arr.borrow();
|
|
assert_eq!(arr.len(), 3);
|
|
assert_num(&arr[0], 1.0);
|
|
assert_num(&arr[1], 2.0);
|
|
assert_num(&arr[2], 3.0);
|
|
}
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_empty_array() {
|
|
match eval_expr("[]") {
|
|
Value::Array(arr) => assert_eq!(arr.borrow().len(), 0),
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_array_index_access() {
|
|
let interp = run("let arr = [10, 20, 30]; let x = arr[0]; let y = arr[2];");
|
|
assert_num(&get_var(&interp, "x"), 10.0);
|
|
assert_num(&get_var(&interp, "y"), 30.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_array_index_assignment() {
|
|
let interp = run("let arr = [1, 2, 3]; arr[0] = 99;");
|
|
match get_var(&interp, "arr") {
|
|
Value::Array(arr) => assert_num(&arr.borrow()[0], 99.0),
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_array_compound_index_assignment() {
|
|
let interp = run("let arr = [1, 2, 3]; arr[0] += 10;");
|
|
match get_var(&interp, "arr") {
|
|
Value::Array(arr) => assert_num(&arr.borrow()[0], 11.0),
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_nested_arrays() {
|
|
let interp = run("let arr = [[1, 2], [3, 4]]; let x = arr[1][0];");
|
|
assert_num(&get_var(&interp, "x"), 3.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_array_equality() {
|
|
assert_bool(&eval_expr("[1, 2, 3] == [1, 2, 3]"), true);
|
|
assert_bool(&eval_expr("[1, 2] == [3, 4]"), false);
|
|
assert_bool(&eval_expr("[1] == [1, 2]"), false);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Object equality
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_object_equality_same() {
|
|
let interp = run("let a = {x: 1, y: 2}; let b = {x: 1, y: 2}; let r = a == b;");
|
|
assert_bool(&get_var(&interp, "r"), true);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_equality_different_values() {
|
|
let interp = run("let a = {x: 1}; let b = {x: 2}; let r = a == b;");
|
|
assert_bool(&get_var(&interp, "r"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_equality_different_keys() {
|
|
let interp = run("let a = {x: 1}; let b = {y: 1}; let r = a == b;");
|
|
assert_bool(&get_var(&interp, "r"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_equality_different_size() {
|
|
let interp = run("let a = {x: 1}; let b = {x: 1, y: 2}; let r = a == b;");
|
|
assert_bool(&get_var(&interp, "r"), false);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_equality_empty() {
|
|
let interp = run("let a = {}; let b = {}; let r = a == b;");
|
|
assert_bool(&get_var(&interp, "r"), true);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Strings as indexable
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_string_index() {
|
|
match eval_expr("\"hello\"[0]") {
|
|
Value::String(s) => assert_eq!(s, "h"),
|
|
v => panic!("Expected String for 'h', got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_string_index_last() {
|
|
match eval_expr("\"abc\"[2]") {
|
|
Value::String(s) => assert_eq!(s, "c"),
|
|
v => panic!("Expected String for 'c', got {:?}", v),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Objects
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_object_creation() {
|
|
match eval_expr("{ name: \"aster\", version: 1 }") {
|
|
Value::Object(obj) => {
|
|
let obj = obj.borrow();
|
|
match obj.get("name") {
|
|
Some(Value::String(s)) => assert_eq!(s, "aster"),
|
|
v => panic!("Expected String 'aster', got {:?}", v),
|
|
}
|
|
match obj.get("version") {
|
|
Some(Value::Number(n)) => assert!((n - 1.0).abs() < f64::EPSILON),
|
|
v => panic!("Expected Number 1, got {:?}", v),
|
|
}
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_property_access() {
|
|
let interp = run("let obj = { name: \"aster\" }; let n = obj.name;");
|
|
match get_var(&interp, "n") {
|
|
Value::String(s) => assert_eq!(s, "aster"),
|
|
v => panic!("Expected String 'aster', got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_property_assignment() {
|
|
let interp = run("let obj = { name: \"old\" }; obj.name = \"new\";");
|
|
match get_var(&interp, "obj") {
|
|
Value::Object(obj) => {
|
|
match obj.borrow().get("name") {
|
|
Some(Value::String(s)) => assert_eq!(s, "new"),
|
|
v => panic!("Expected String 'new', got {:?}", v),
|
|
}
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_compound_property_assignment() {
|
|
let interp = run("let obj = { age: 26 }; obj.age -= 2;");
|
|
match get_var(&interp, "obj") {
|
|
Value::Object(obj) => {
|
|
assert_num(obj.borrow().get("age").unwrap(), 24.0);
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Built-in functions
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_builtin_clock() {
|
|
// clock() returns a number (Unix timestamp in seconds)
|
|
match eval_expr("clock()") {
|
|
Value::Number(n) => assert!(n > 0.0, "clock should return positive number"),
|
|
v => panic!("Expected Number from clock(), got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_builtin_os_clock() {
|
|
match eval_expr("os.clock()") {
|
|
Value::Number(n) => assert!(n > 0.0),
|
|
v => panic!("Expected Number from os.clock(), got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_print_returns_nil() {
|
|
// print() returns nil
|
|
assert_nil(&eval_expr("print(\"test\")"));
|
|
}
|
|
|
|
// =========================================================================
|
|
// Runtime errors
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn error_undefined_variable() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
run("let x = y;");
|
|
});
|
|
// run() asserts no errors, so this should panic
|
|
assert!(result.is_err(), "Expected error for undefined variable");
|
|
}
|
|
|
|
#[test]
|
|
fn error_division_by_zero() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("1 / 0");
|
|
});
|
|
assert!(result.is_err(), "Expected error for division by zero");
|
|
}
|
|
|
|
#[test]
|
|
fn error_modulo_by_zero() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("1 % 0");
|
|
});
|
|
assert!(result.is_err(), "Expected error for modulo by zero");
|
|
}
|
|
|
|
#[test]
|
|
fn error_type_mismatch_negate_string() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("-\"hello\"");
|
|
});
|
|
assert!(result.is_err(), "Expected error for negating a string");
|
|
}
|
|
|
|
#[test]
|
|
fn eval_number_plus_string_concatenates() {
|
|
match eval_expr("1 + \"hello\"") {
|
|
Value::String(s) => assert_eq!(s, "1hello"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn error_call_non_function() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("42()");
|
|
});
|
|
assert!(result.is_err(), "Expected error for calling non-function");
|
|
}
|
|
|
|
#[test]
|
|
fn error_index_out_of_bounds() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("[1, 2][5]");
|
|
});
|
|
assert!(result.is_err(), "Expected error for index out of bounds");
|
|
}
|
|
|
|
#[test]
|
|
fn error_property_on_non_object() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("42.name");
|
|
});
|
|
assert!(result.is_err(), "Expected error for property on non-object");
|
|
}
|
|
|
|
#[test]
|
|
fn error_index_on_non_array() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("42[0]");
|
|
});
|
|
assert!(result.is_err(), "Expected error for index on non-array");
|
|
}
|
|
|
|
// =========================================================================
|
|
// Object index access: obj[key]
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_object_index_get() {
|
|
assert_num(&eval_expr("{a: 42}[\"a\"]"), 42.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_index_get_nested() {
|
|
assert_num(&eval_expr("{inner: {val: 7}}[\"inner\"][\"val\"]"), 7.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_index_get_variable_key() {
|
|
let interp = run("let obj = {x: 10, y: 20}; let k = \"y\"; let result = obj[k];");
|
|
assert_num(&get_var(&interp, "result"), 20.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_index_get_undefined() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("{}[\"x\"]");
|
|
});
|
|
assert!(result.is_err(), "Expected error for undefined property");
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_index_set_existing() {
|
|
let interp = run("let obj = {a: 1}; obj[\"a\"] = 99;");
|
|
match get_var(&interp, "obj") {
|
|
Value::Object(map) => {
|
|
let map = map.borrow();
|
|
assert_num(map.get("a").unwrap(), 99.0);
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_index_set_new_key() {
|
|
let interp = run("let obj = {}; obj[\"name\"] = \"Aster\";");
|
|
match get_var(&interp, "obj") {
|
|
Value::Object(map) => {
|
|
let map = map.borrow();
|
|
match map.get("name").unwrap() {
|
|
Value::String(s) => assert_eq!(s, "Aster"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_object_index_compound_assign() {
|
|
let interp = run("let obj = {count: 10}; obj[\"count\"] += 5;");
|
|
match get_var(&interp, "obj") {
|
|
Value::Object(map) => {
|
|
let map = map.borrow();
|
|
assert_num(map.get("count").unwrap(), 15.0);
|
|
}
|
|
v => panic!("Expected Object, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn error_object_index_non_string() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("{a: 1}[42]");
|
|
});
|
|
assert!(result.is_err(), "Expected error for non-string object index");
|
|
}
|
|
|
|
#[test]
|
|
fn error_object_index_set_non_string() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("let obj = {a: 1}; obj[true] = 2;");
|
|
});
|
|
assert!(result.is_err(), "Expected error for non-string object index set");
|
|
}
|
|
|
|
// =========================================================================
|
|
// Builtins: len
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_len_string() {
|
|
assert_num(&eval_expr("len(\"hello\")"), 5.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_len_empty_string() {
|
|
assert_num(&eval_expr("len(\"\")"), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_len_array() {
|
|
assert_num(&eval_expr("len([1, 2, 3])"), 3.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_len_empty_array() {
|
|
assert_num(&eval_expr("len([])"), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_len_object() {
|
|
assert_num(&eval_expr("len({a: 1, b: 2})"), 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_len_empty_object() {
|
|
assert_num(&eval_expr("len({})"), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn error_len_no_args() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("len()");
|
|
});
|
|
assert!(result.is_err(), "Expected error for len() with no args");
|
|
}
|
|
|
|
#[test]
|
|
fn error_len_number() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("len(42)");
|
|
});
|
|
assert!(result.is_err(), "Expected error for len(42)");
|
|
}
|
|
|
|
// =========================================================================
|
|
// Builtins: typeof
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_typeof_number() {
|
|
match eval_expr("typeof(42)") {
|
|
Value::String(s) => assert_eq!(s, "number"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_typeof_string() {
|
|
match eval_expr("typeof(\"hello\")") {
|
|
Value::String(s) => assert_eq!(s, "string"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_typeof_bool() {
|
|
match eval_expr("typeof(true)") {
|
|
Value::String(s) => assert_eq!(s, "bool"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_typeof_nil() {
|
|
match eval_expr("typeof(nil)") {
|
|
Value::String(s) => assert_eq!(s, "nil"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_typeof_object() {
|
|
match eval_expr("typeof({a: 1})") {
|
|
Value::String(s) => assert_eq!(s, "object"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_typeof_array() {
|
|
match eval_expr("typeof([1, 2])") {
|
|
Value::String(s) => assert_eq!(s, "array"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_typeof_function() {
|
|
let interp = run("fn f() {}");
|
|
// f is a variable, not an expression — use get_var
|
|
match get_var(&interp, "f") {
|
|
Value::Function(_) => {} // just verify it's a function
|
|
v => panic!("Expected Function, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// Builtins: push / pop
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_push_returns_value() {
|
|
assert_num(&eval_expr("push([1, 2], 3)"), 3.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_push_modifies_array() {
|
|
let interp = run("let arr = [1, 2]; push(arr, 3);");
|
|
match get_var(&interp, "arr") {
|
|
Value::Array(arr) => {
|
|
let arr = arr.borrow();
|
|
assert_eq!(arr.len(), 3);
|
|
assert_num(&arr[0], 1.0);
|
|
assert_num(&arr[1], 2.0);
|
|
assert_num(&arr[2], 3.0);
|
|
}
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_push_string_to_array() {
|
|
let interp = run("let arr = [\"a\"]; push(arr, \"b\");");
|
|
match get_var(&interp, "arr") {
|
|
Value::Array(arr) => {
|
|
let arr = arr.borrow();
|
|
assert_eq!(arr.len(), 2);
|
|
}
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_pop_returns_last() {
|
|
assert_num(&eval_expr("pop([1, 2, 3])"), 3.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_pop_modifies_array() {
|
|
let interp = run("let arr = [1, 2, 3]; pop(arr);");
|
|
match get_var(&interp, "arr") {
|
|
Value::Array(arr) => {
|
|
let arr = arr.borrow();
|
|
assert_eq!(arr.len(), 2);
|
|
assert_num(&arr[0], 1.0);
|
|
assert_num(&arr[1], 2.0);
|
|
}
|
|
v => panic!("Expected Array, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn error_pop_empty_array() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("pop([])");
|
|
});
|
|
assert!(result.is_err(), "Expected error for pop([])");
|
|
}
|
|
|
|
#[test]
|
|
fn error_push_non_array() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("push(42, 1)");
|
|
});
|
|
assert!(result.is_err(), "Expected error for push on non-array");
|
|
}
|
|
|
|
#[test]
|
|
fn error_pop_non_array() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("pop(42)");
|
|
});
|
|
assert!(result.is_err(), "Expected error for pop on non-array");
|
|
}
|
|
|
|
// =========================================================================
|
|
// For-In loops
|
|
// =========================================================================
|
|
|
|
#[test]
|
|
fn eval_forin_array_elements() {
|
|
// Sum elements via for-in
|
|
let interp = run("let sum = 0; let arr = [1, 2, 3]; for (x in arr) { sum = sum + x; }");
|
|
assert_num(&get_var(&interp, "sum"), 6.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_empty_array() {
|
|
let interp = run("let count = 0; let arr = []; for (x in arr) { count = count + 1; }");
|
|
assert_num(&get_var(&interp, "count"), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_object_keys() {
|
|
let interp = run("let keys = \"\"; let obj = {a: 1, b: 2}; for (k in obj) { keys = keys + k; }");
|
|
match get_var(&interp, "keys") {
|
|
Value::String(s) => {
|
|
// Object iteration order is not guaranteed, so check length
|
|
assert_eq!(s.len(), 2);
|
|
assert!(s.contains('a'));
|
|
assert!(s.contains('b'));
|
|
}
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_string_chars() {
|
|
let interp = run("let result = \"\"; for (c in \"ab\") { result = result + c; }");
|
|
match get_var(&interp, "result") {
|
|
Value::String(s) => assert_eq!(s, "ab"),
|
|
v => panic!("Expected String, got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_break() {
|
|
let interp = run("let sum = 0; for (x in [1, 2, 3, 4]) { if (x == 3) { break; } sum = sum + x; }");
|
|
assert_num(&get_var(&interp, "sum"), 3.0); // 1 + 2
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_continue() {
|
|
let interp = run("let sum = 0; for (x in [1, 2, 3]) { if (x == 2) { continue; } sum = sum + x; }");
|
|
assert_num(&get_var(&interp, "sum"), 4.0); // 1 + 3
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_loop_var_doesnt_leak() {
|
|
// Loop variable should not be accessible outside the loop
|
|
let interp = run("for (x in [1]) { let _ = x; }");
|
|
// x should not exist in the outer scope
|
|
match get_var(&interp, "x") {
|
|
Value::Nil => {} // Expected: x is not defined
|
|
v => panic!("Expected Nil (undefined), got {:?}", v),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn eval_forin_with_object_array() {
|
|
// Iterate over an array of objects
|
|
let interp = run("
|
|
let arr = [{v: 10}, {v: 20}];
|
|
let total = 0;
|
|
for (obj in arr) { total = total + obj.v; }
|
|
");
|
|
assert_num(&get_var(&interp, "total"), 30.0);
|
|
}
|
|
|
|
#[test]
|
|
fn error_forin_non_iterable() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
run("for (x in 42) { let _ = x; }"); // Can't iterate a number
|
|
});
|
|
assert!(result.is_err(), "Expected error for for-in on non-iterable");
|
|
}
|
|
}
|
|
|