small fixes and interpreter update

working on an iPad is difficult...

Author: DigitalCodeCrafter

src/interpreter.rs

@@ -4,6 +4,7 @@ use crate::common::diagnostics::sinks::Diagnostics;
 use crate::syntax::*;
 
 pub struct Env<'a> {
+    parent: Option<&'a Env<'a>>
     vars: HashMap<&'a str, f64>,
 }
 
@@ -18,7 +19,7 @@ pub fn interpret_program<'a>(src: &'a str) -> (HashMap<&'a str, f64>, Vec<EvalEr
     let mut diagnostics = Diagnostics::empty();
     let ast = parse(src, &mut diagnostics);
 
-    let mut env = Env { vars: HashMap::new() };
+    let mut env = Env { parent: None, vars: HashMap::new() };
     let mut errors = Vec::new();
 
     for stmt in &ast.stmts {
@@ -51,10 +52,21 @@ fn eval_expr<'a>(expr: &Expr<'a>, env: &Env<'a>) -> Result<f64, EvalError> {
     match &expr.kind {
         ExprKind::Number { value, .. } => Ok(*value),
 
-        ExprKind::Identifier { name } => env.vars
-            .get(name)
-            .copied()
-            .ok_or(EvalError::UnknownVariable(name.to_string(), expr.span)),
+        ExprKind::Identifier { name } => {
+            let mut current = env;
+            loop {
+                let found = current.vars.get(name).copied();
+
+                if let Some(val) = found {
+                    return Ok(val)
+                }
+
+                match current.parent {
+                    Some(p) => current = p,
+                    None => return Err(EvalError::UnknownVariable(name.to_string(), expr.span)),
+                }
+            }
+        }
 
         ExprKind::BinaryOp { op, left, right } => {
             let l = eval_expr(left, env)?;
@@ -68,6 +80,16 @@ fn eval_expr<'a>(expr: &Expr<'a>, env: &Env<'a>) -> Result<f64, EvalError> {
             }
         }
 
+        ExprKind::Block { stmts, tail_expr } => {
+            let mut inner_env = Env { parent: Some(env), vars: HashMap::new() };
+
+            for stmt in stmts {
+                eval_stmt(&mut inner_env, stmt)?;
+            }
+
+            tail_expr.map(|expr| eval_expr(&inner_env, expr)).unwrap_or(Ok(0.0))
+        }
+
         ExprKind::Error => Err(EvalError::InvalidExpression(expr.span)),
     }
 }

src/semantics/resolver.rs

@@ -230,7 +230,7 @@ impl<'d, D: DiagnosticSink> Resolver<'d, D> {
                     .map(|stmt| self.resolve_stmt(stmt))
                     .collect();
 
-                let resolved_expr = tail_expr.map(|expr| self.resolve_expr(expr));
+                let resolved_expr = tail_expr.map(|expr| Box::new(self.resolve_expr(*expr)));
 
                 self.current_scope = outer;
                 r::ExprKind::Block { stmts: resolved_stmts, tail_expr: resolved_expr }

src/syntax/parser.rs

@@ -344,8 +344,9 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
 
         let tail_expr = match stmts.pop() {
             Some(Stmt { kind: StmtKind::Expr(expr), span }) if expr.span != span => Some(Box::new(expr)),
-            other => { stmts.push(other); None }
-        }
+            Some(other) => { stmts.push(other); None }
+            _ => None,
+        };
 
         Expr {
             kind: ExprKind::Block { stmts, tail_expr },