finished resolver (chapter 11) and started classes (chapter 12)

interpreter/src/interpret.rs

@@ -0,0 +1,250 @@
+use std::rc::Rc;
+
+use rlox2_frontend::parser::{BinaryOp, Expr, Literal, LogicalOp, Stmt, UnaryOp};
+
+use crate::error::RuntimeError;
+use crate::LoxClass;
+
+use super::environment::Environment;
+use super::{LoxFunction, Runtime, Value};
+
+pub type EvalResult<T> = Result<T, RuntimeError>;
+
+/*====================================================================================================================*/
+
+pub fn execute(statement: Stmt, runtime: &mut Runtime) -> Result<(), RuntimeError> {
+    let mut env = Environment::new(runtime);
+
+    statement.eval(&mut env)?;
+
+    Ok(())
+}
+
+/*====================================================================================================================*/
+
+trait Eval {
+    fn eval(&self, env: &mut Environment) -> EvalResult<Value>;
+}
+
+impl Eval for 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 Eval for 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 } => panic!("Unresolved variable {name}"),
+            Expr::LocalVariable { name, level } => env.get_local(name, *level),
+            Expr::GlobalVariable { name } => env.get_global(name),
+            Expr::Assignment { target, value } => {
+                let value = value.eval(env)?;
+
+                match target.as_ref() {
+                    Expr::LocalVariable { name, level } => env.assign(name, value.clone(), *level)?,
+                    Expr::GlobalVariable { name } => env.assign_global(name, value.clone())?,
+                    _ => panic!("Invalid assigment target {target}"),
+                }
+                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,
+                closure_vars,
+                body,
+            } => Ok(Value::function(LoxFunction::new(
+                name,
+                env.collect_closure(closure_vars),
+                param_names.clone(),
+                body.as_ref().clone(),
+            ))),
+        }
+    }
+}
+
+impl Eval for Stmt {
+    fn eval(&self, env: &mut Environment) -> EvalResult<Value> {
+        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}"),
+                }
+            }
+            Stmt::IfStmt {
+                condition,
+                then_branch,
+                else_branch,
+            } => {
+                let condition = condition.eval(env)?;
+                if condition.is_truthy() {
+                    then_branch.eval(env)?;
+                } else if let Some(else_branch) = else_branch {
+                    else_branch.eval(env)?;
+                }
+            }
+            Stmt::While { condition, body } => {
+                while condition.eval(env)?.is_truthy() {
+                    match body.eval(env) {
+                        Ok(_) => {}
+                        Err(RuntimeError::Break) => break,
+                        Err(err) => return Err(err),
+                    }
+                }
+            }
+            Stmt::VarDecl { name, initializer } => {
+                let initializer = initializer.eval(env)?;
+                env.define(name, initializer);
+            }
+            Stmt::Block { statements } => {
+                env.enter_scope();
+                for statement in statements {
+                    if let Err(err) = statement.eval(env) {
+                        env.exit_scope();
+                        return Err(err);
+                    }
+                }
+                env.exit_scope();
+            }
+            Stmt::Class { name, methods: _ } => {
+                env.define(name, Value::Nil);
+
+                let class = Value::class(LoxClass::new(name));
+
+                env.assign(name, class, 0)?;
+            }
+            Stmt::ExprStmt { expr } => {
+                // expr.eval(env)?;
+                // Ok(Value::Nil)
+                expr.eval(env)?;
+            }
+            Stmt::Break => return Err(RuntimeError::Break),
+            Stmt::Return { expr } => {
+                let value = expr.eval(env)?;
+                return Err(RuntimeError::Return { value });
+            }
+        }
+
+        Ok(Value::Nil)
+    }
+}
+
+/*====================================================================================================================*/
+
+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_scope(self.closure().clone());
+
+        for (name, value) in std::iter::zip(self.param_names(), args) {
+            env.define(name, value);
+        }
+
+        let ret_val = match self.body().eval(env) {
+            Ok(_) => Ok(Value::Nil),
+            Err(RuntimeError::Return { value }) => Ok(value),
+            Err(err) => Err(err),
+        };
+
+        env.exit_scope();
+
+        ret_val
+    }
+}