more fixes

Author: DigitalCodeCrafter

src/interpreter.rs

@@ -4,7 +4,7 @@ use crate::common::diagnostics::sinks::Diagnostics;
 use crate::syntax::*;
 
 pub struct Env<'a> {
-    parent: Option<&'a Env<'a>>
+    parent: Option<&'a Env<'a>>,
     vars: HashMap<&'a str, f64>,
 }
 
@@ -84,10 +84,10 @@ fn eval_expr<'a>(expr: &Expr<'a>, env: &Env<'a>) -> Result<f64, EvalError> {
             let mut inner_env = Env { parent: Some(env), vars: HashMap::new() };
 
             for stmt in stmts {
-                eval_stmt(&mut inner_env, stmt)?;
+                eval_stmt(stmt, &mut inner_env)?;
             }
 
-            tail_expr.map(|expr| eval_expr(&inner_env, expr)).unwrap_or(Ok(0.0))
+            tail_expr.map(|expr| eval_expr(expr, &inner_env)).unwrap_or(Ok(0.0))
         }
 
         ExprKind::Error => Err(EvalError::InvalidExpression(expr.span)),

src/ir/lowerer.rs

@@ -128,6 +128,19 @@ impl FunctionIRBuilder<'_> {
                 });
                 dst
             }
+            t::ExprKind::Block { stmts, tail_expr } => {
+                for stmt in stmts {
+                    self.lower_stmt();
+                }
+
+                match tail_expr {
+                    Some(expr) => self.lower_expr(*expr),
+                    None => {
+                        let dst = self.new_temp(Type::Unit);
+                        todo!("Load unit into temporary")
+                    }
+                }
+            }
             t::ExprKind::Error => {
                 let dst = self.new_temp(expr.ty);
                 self.emit(Instr::Poision { dst: Some(dst) });

src/semantics/typechecker.rs

@@ -106,7 +106,7 @@ impl TypeChecker<'_> {
                     .map(|stmt| self.check_stmt(stmt))
                     .collect();
 
-                let typed_expr = tail_expr.map(|expr| self.infer(expr));
+                let typed_expr = tail_expr.map(|expr| Box::new(self.infer(*expr)));
 
                 let ty = typed_expr.map(|e| e.ty.clone()).unwrap_or(Type::Unit);
 

src/syntax/parser.rs

@@ -156,10 +156,18 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
     }
 
     fn expect_terminator(&mut self) -> Option<Token> {
+        let save = self.stream.get_position();
+        self.skip_newlines();
         match self.peek_token() {
-            Token { kind: TokenKind::Semicolon | TokenKind::Newline, .. } => self.stream.next(),
+            Token { kind: TokenKind::Semicolon, .. } => self.stream.next(),
             Token { kind: TokenKind::RBrace | TokenKind::EOF, .. } => None,
             other => {
+                // skipped at least one newline
+                if save != self.stream.get_position() {
+                    self.stream.set_position(save);
+                    return self.stream.next();
+                }
+                
                 self.diags.emit(
                     Diagnostic::error("missing statement terminator")
                     .with_span(other.span)
@@ -343,7 +351,7 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
         let span = closing_tok.map(|t| t.span.concat(&tok.span)).unwrap_or(tok.span);
 
         let tail_expr = match stmts.pop() {
-            Some(Stmt { kind: StmtKind::Expr(expr), span }) if expr.span != span => Some(Box::new(expr)),
+            Some(Stmt { kind: StmtKind::Expr(expr), span }) if expr.span == span => Some(Box::new(expr)),
             Some(other) => { stmts.push(other); None }
             _ => None,
         };