⚠️ Removed compiler warnings

src/functions.rs

@@ -53,7 +53,7 @@ impl Function {
     }
 
     pub fn bind(&self, instance: &Object) -> Object {
-        let mut e = RefCell::new(Environment::new_with_enclosing(Rc::clone(&self.closure)));
+        let e = RefCell::new(Environment::new_with_enclosing(Rc::clone(&self.closure)));
         e.borrow_mut().define("this".to_string(), instance.clone());
         Object::Function(Rc::new(Self {
             name: self.name.clone(),

src/interpreter.rs

@@ -189,7 +189,7 @@ impl ExprVisitor<Object> for Interpreter {
         self.look_up_variable(&expr.keyword, wrapper)
     }
 
-    fn visit_set_expr(&self, wrapper: Rc<Expr>, expr: &SetExpr) -> Result<Object, Error> {
+    fn visit_set_expr(&self, _wrapper: Rc<Expr>, expr: &SetExpr) -> Result<Object, Error> {
         let object = self.evaluate(expr.object.clone())?;
 
         if let Object::Instance(inst) = object {
@@ -204,7 +204,7 @@ impl ExprVisitor<Object> for Interpreter {
         ))
     }
 
-    fn visit_get_expr(&self, wrapper: Rc<Expr>, expr: &GetExpr) -> Result<Object, Error> {
+    fn visit_get_expr(&self, _wrapper: Rc<Expr>, expr: &GetExpr) -> Result<Object, Error> {
         let object = self.evaluate(expr.object.clone())?;
 
         if let Object::Instance(inst) = object {

src/main.rs

@@ -39,7 +39,7 @@ mod instance;
 
 fn eval(source: &str) -> Result<(), Error> {
     let lexer = Lexer::new(source.to_string());
-    let mut tokens: Vec<Token> = lexer.collect();
+    let tokens: Vec<Token> = lexer.collect();
 
     let mut parser = Parser::new(tokens);
     let statements = parser.parse();
@@ -67,15 +67,15 @@ fn repl() {
             "@" => interpreter.print_env(),
             _ => {
                 let lexer = Lexer::new(input);
-                let mut tokens: Vec<Token> = lexer.collect();
+                let tokens: Vec<Token> = lexer.collect();
 
                 let mut parser = Parser::new(tokens);
                 let statements = parser.parse();
 
                 match statements {
                     Ok(statements) => {
                         let s = Rc::new(statements);
-                        let mut resolver = Resolver::new(&interpreter);
+                        let resolver = Resolver::new(&interpreter);
                         resolver.resolve(&Rc::clone(&s));
 
                         if resolver.success() {
@@ -85,7 +85,7 @@ fn repl() {
                         }
 
                     }
-                    Err(e) => println!("Error"),
+                    Err(_) => std::process::exit(2),
                 }
             }
         }

src/resolver.rs

@@ -257,11 +257,11 @@ impl<'a> Resolver<'a> {
     }
 
     fn resolve_stmt(&self, stmt: Rc<Stmt>){
-        stmt.accept(stmt.clone(), self);
+        let _ = stmt.accept(stmt.clone(), self);
     }
 
     fn resolve_expr(&self, expr: Rc<Expr>){
-        expr.accept(expr.clone(), self);
+        let _ = expr.accept(expr.clone(), self);
     }
 
     fn begin_scope(&self) {

src/tokens.rs

@@ -1,5 +1,4 @@
 use std::fmt;
-use crate::callable::Callable;
 use crate::errors::*;
 use crate::interpreter::Interpreter;
 use crate::callable::*;