minor stuff

frontend/src/parser/stmt.rs

@@ -93,10 +93,12 @@ impl Display for Stmt {
                 else_branch,
             } => {
                 writeln!(f, "if {condition}")?;
+
                 match then_branch.as_ref() {
-                    Stmt::Block { .. } => write!(f, "{then_branch}")?,
+                    Stmt::Block { .. } => write!(f, "{}", indent(then_branch.to_string()))?,
                     _ => write!(f, "{}", indent(then_branch.to_string()))?,
                 }
+
                 if let Some(else_branch) = else_branch {
                     writeln!(f, "\nelse")?;
                     match else_branch.as_ref() {
@@ -104,6 +106,7 @@ impl Display for Stmt {
                         _ => write!(f, "{}", indent(else_branch.to_string()))?,
                     }
                 }
+
                 Ok(())
             }
             Stmt::While { condition, body } => {

interpreter/src/interpreter.rs

@@ -135,10 +135,6 @@ impl Eval for Expr {
             }
             Expr::Call { callee, args } => {
                 let callee = callee.eval(env)?;
-                /* let args = args
-                .iter()
-                .map(|arg| arg.eval(env))
-                .collect::<EvalResult<Vec<Value>>>()?; */
 
                 for arg in args {
                     let arg = arg.eval(env)?;

interpreter/src/resolver/_resolver.rs

@@ -106,7 +106,7 @@ impl Resolver {
         if let Some(local_scope) = self.local_scopes_mut().last_mut() {
             local_scope.insert(name, ResolveStatus::Defined);
         } else {
-            self.global_scope.insert(name, ResolveStatus::Declared);
+            self.global_scope.insert(name, ResolveStatus::Defined);
         }
     }
 
@@ -119,8 +119,15 @@ impl Resolver {
     }
 
     fn resolve_var(&mut self, name: &str) -> ResolverResult<Expr> {
+        if name == "this" {
+            return Err(ResolverError::ThisOutsideMethod);
+        } else if name == "super" {
+            return Err(ResolverError::SuperOutsideMethod);
+        }
+
         let mut level = 0;
 
+        // resolve normal local variable
         for scope in self.local_scopes().iter().rev() {
             if scope.contains_key(name) {
                 return Ok(Expr::local_variable(name, level));
@@ -128,6 +135,7 @@ impl Resolver {
             level += 1;
         }
 
+        // resolve closure variable
         for frame in self.frames.iter().rev().skip(1) {
             for scope in frame.iter().rev() {
                 if scope.contains_key(name) {
@@ -147,19 +155,15 @@ impl Resolver {
             }
         }
 
+        // resolve global variable
         if self.global_scope.contains_key(name) {
             return Ok(Expr::global_variable(name));
         }
 
-        if name == "this" {
-            Err(ResolverError::ThisOutsideMethod)
-        } else if name == "super" {
-            Err(ResolverError::SuperOutsideMethod)
-        } else {
         let name = name.into();
+
         Err(ResolverError::UnresolvableVariable { name })
     }
-    }
 
     fn resolve_stmt(&mut self, stmt: &mut Stmt) -> ResolverResult<()> {
         match stmt {
@@ -234,6 +238,7 @@ impl Resolver {
             Expr::Variable { name } => {
                 if let Some(ResolveStatus::Declared) = self.check(name) {
                     let name = name.clone();
+
                     return Err(ResolverError::VarInOwnInitializer { name });
                 }
 
@@ -241,7 +246,7 @@ impl Resolver {
 
                 Ok(())
             }
-            Expr::LocalVariable { name, level: _ } => {
+            Expr::LocalVariable { name, .. } => {
                 panic!("Tried to resolve variable {name} twice")
             }
             Expr::GlobalVariable { name } => {
@@ -302,6 +307,7 @@ impl Resolver {
 
                 for param_name in param_names.iter() {
                     self.declare(param_name.clone())?;
+
                     self.define(param_name.clone());
                 }