rlox/src/interpreter/interpret.rs

use std::rc::Rc;

use crate::error::RuntimeError;
use crate::parser::{BinaryOp, Expr, Literal, LogicalOp, Stmt, UnaryOp};

use super::environment::Environment;
use super::{LoxFunction, Value};

pub type EvalResult<T> = Result<T, RuntimeError>;

/*====================================================================================================================*/

pub fn execute(statement: Stmt, env: &mut Environment) -> Result<(), RuntimeError> {
    statement.execute(env)
}

/*====================================================================================================================*/

/* trait Eval {
    fn eval(self, env: &mut Environment) -> EvalResult;
} */

impl Literal {
    fn eval(&self, env: &mut Environment) -> EvalResult<Value> {
        let _ = env;
        match self {
            Literal::String(s) => Ok(Value::String(Rc::clone(s))),
            Literal::Number(num) => Ok(Value::Number(*num)),
            Literal::Bool(b) => Ok(Value::Bool(*b)),
            Literal::Nil => Ok(Value::Nil),
        }
    }
}

impl Expr {
    fn eval(&self, env: &mut Environment) -> EvalResult<Value> {
        match self {
            Expr::Literal { literal } => literal.eval(env),
            Expr::Unary { op, expr } => {
                let arg = expr.eval(env)?;

                match (*op, arg) {
                    (UnaryOp::Negate, Value::Number(num)) => Ok(Value::Number(-num)),
                    (UnaryOp::Not, Value::Bool(b)) => Ok(Value::Bool(!b)),
                    (UnaryOp::Not, primitive) => Ok(Value::Bool(!primitive.is_truthy())),
                    (op, arg) => Err(RuntimeError::UnaryOpInvalidArgument { op, arg }),
                }
            }
            Expr::Binary { left, op, right } => {
                use Value::{Bool, Number, String};

                let left = left.eval(env)?;
                let right = right.eval(env)?;

                match (left, *op, right) {
                    (Number(left), BinaryOp::Add, Number(right)) => Ok(Number(left + right)),
                    (Number(left), BinaryOp::Subtract, Number(right)) => Ok(Number(left - right)),
                    (Number(left), BinaryOp::Multiply, Number(right)) => Ok(Number(left * right)),
                    (Number(left), BinaryOp::Divide, Number(right)) => {
                        if right == 0.0 {
                            return Err(RuntimeError::DivisionByZero);
                        }
                        Ok(Number(left / right))
                    }

                    (String(left), BinaryOp::Add, String(right)) => {
                        let mut s = std::string::String::with_capacity(left.capacity() + right.capacity());
                        s += &left;
                        s += &right;
                        Ok(String(Rc::new(s)))
                    }

                    (left, BinaryOp::Equal, right) => Ok(Bool(left == right)),
                    (left, BinaryOp::NotEqual, right) => Ok(Bool(left != right)),

                    (Number(left), BinaryOp::Less, Number(right)) => Ok(Bool(left < right)),
                    (Number(left), BinaryOp::LessEqual, Number(right)) => Ok(Bool(left <= right)),
                    (Number(left), BinaryOp::Greater, Number(right)) => Ok(Bool(left > right)),
                    (Number(left), BinaryOp::GreaterEqual, Number(right)) => Ok(Bool(left >= right)),

                    (String(left), BinaryOp::Less, String(right)) => Ok(Bool(left < right)),
                    (String(left), BinaryOp::LessEqual, String(right)) => Ok(Bool(left <= right)),
                    (String(left), BinaryOp::Greater, String(right)) => Ok(Bool(left > right)),
                    (String(left), BinaryOp::GreaterEqual, String(right)) => Ok(Bool(left >= right)),

                    (left, op, right) => Err(RuntimeError::BinaryOpInvalidArguments { left, op, right }),
                }
            }
            Expr::Logical { left, op, right } => {
                let left = left.eval(env)?;
                match op {
                    LogicalOp::Or => {
                        if left.is_truthy() {
                            return Ok(left);
                        }
                    }
                    LogicalOp::And => {
                        if !left.is_truthy() {
                            return Ok(left);
                        }
                    }
                }
                let right = right.eval(env)?;
                Ok(right)
            }
            Expr::Grouping { expr } => expr.eval(env),
            Expr::Variable { name } => env.get(name),
            Expr::Assignment { name, value } => {
                let value = value.eval(env)?;
                env.assign(name, value.clone())?;
                Ok(value)
            }
            Expr::Call { callee, args } => {
                let callee = callee.eval(env)?;
                let args = args
                    .iter()
                    .map(|arg| arg.eval(env))
                    .collect::<EvalResult<Vec<Value>>>()?;

                match callee {
                    Value::Function(fun) => fun.call(args, env),
                    Value::ExternFunction(ext_fun) => ext_fun.call(args, env),
                    _ => Err(RuntimeError::NotCallable { callee }),
                }
            }
            Expr::Function {
                name,
                param_names,
                body,
            } => Ok(Value::function(LoxFunction::new(
                name,
                param_names.clone(),
                body.as_ref().clone(),
            ))),
        }
    }
}

impl Stmt {
    fn execute(&self, env: &mut Environment) -> EvalResult<()> {
        match self {
            Stmt::Print { expr } => {
                match expr.eval(env)? {
                    // special case: when printing a string, drop the surrounding ""
                    Value::String(s) => println!("{s}"),
                    val => println!("{val}"),
                }

                Ok(())
            }
            Stmt::IfStmt {
                condition,
                then_branch,
                else_branch,
            } => {
                let condition = condition.eval(env)?;
                if condition.is_truthy() {
                    then_branch.execute(env)
                } else if let Some(else_branch) = else_branch {
                    else_branch.execute(env)
                } else {
                    Ok(())
                }
            }
            Stmt::While { condition, body } => {
                while condition.eval(env)?.is_truthy() {
                    match body.execute(env) {
                        Ok(_) => {}
                        Err(RuntimeError::Break) => break,
                        Err(err) => return Err(err),
                    }
                }
                Ok(())
            }
            Stmt::VarDecl { name, initializer } => {
                let initializer = initializer.eval(env)?;
                env.define(name.as_ref(), initializer);
                Ok(())
            }
            Stmt::Block { statements } => {
                env.enter_scope();
                for statement in statements {
                    // on error the current frame gets destroyed anyways, so no need to exit scope
                    statement.execute(env)?;
                }
                env.exit_scope();
                Ok(())
            }
            Stmt::ExprStmt { expr } => {
                // expr.eval(env)?;
                // Ok(Value::Nil)
                expr.eval(env)?;
                Ok(())
            }
            Stmt::Break => Err(RuntimeError::Break),
            Stmt::Return { expr } => {
                let value = expr.eval(env)?;
                Err(RuntimeError::Return { value })
            }
        }
    }
}

/*====================================================================================================================*/

impl LoxFunction {
    pub fn call(&self, args: Vec<Value>, env: &mut Environment) -> EvalResult<Value> {
        if args.len() != self.arity() {
            return Err(RuntimeError::WrongArity {
                name: self.name().to_owned(),
                arity: self.arity(),
                given: args.len(),
            });
        }

        env.push_frame(self.closure().clone());

        for (name, value) in std::iter::zip(self.param_names(), args) {
            env.define(name.as_ref(), value);
        }

        let ret_val = match self.body().execute(env) {
            Ok(()) => Value::Nil,
            Err(RuntimeError::Return { value }) => value,
            Err(err) => return Err(err),
        };

        env.pop_frame();

        Ok(ret_val)
    }
}