0264408
1171 lines
41 KiB
Rust
1171 lines
41 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 } => {
|
|
let val = self.evaluate(initializer)?;
|
|
self.env.borrow_mut().define(name, val);
|
|
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::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);
|
|
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)?
|
|
}
|
|
};
|
|
if !self.env.borrow_mut().assign(&name, val.clone()) {
|
|
return Err(RuntimeError::RuntimeError {
|
|
message: format!("Undefined variable '{}'", name),
|
|
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 arr = self.evaluate(*array)?;
|
|
let idx = self.evaluate(*index)?;
|
|
let i = self.as_array_index(&idx)?;
|
|
match arr {
|
|
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 value".to_string(),
|
|
token: None,
|
|
}),
|
|
}
|
|
}
|
|
Expr::IndexSet { array, index, op, value } => {
|
|
let arr = self.evaluate(*array)?;
|
|
let idx = self.evaluate(*index)?;
|
|
let rhs = self.evaluate(*value)?;
|
|
let i = self.as_array_index(&idx)?;
|
|
match arr {
|
|
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 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 => match (l, r) {
|
|
(Value::Number(a), Value::Number(b)) => Ok(Value::Number(a+b)),
|
|
(Value::String(a), Value::String(b)) => Ok(Value::String(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(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(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::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) => {
|
|
Ok(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)));
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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))
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn apply_assign_op(&self, left: Value, right: Value, op: AssignOp) -> Result<Value, RuntimeError> {
|
|
match op {
|
|
AssignOp::Equal => Ok(right),
|
|
AssignOp::PlusEqual => {
|
|
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),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// 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),
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// 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);
|
|
}
|
|
|
|
// =========================================================================
|
|
// 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);
|
|
}
|
|
|
|
// =========================================================================
|
|
// 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_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 error_type_mismatch_add_number_and_string() {
|
|
let result = std::panic::catch_unwind(|| {
|
|
eval_expr("1 + \"hello\"");
|
|
});
|
|
assert!(result.is_err(), "Expected error for adding number + string");
|
|
}
|
|
|
|
#[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");
|
|
}
|
|
}
|
|
|