apply clippy suggestions

Author: Robbepop

src/jit.rs

@@ -45,8 +45,7 @@ impl JIT {
             parser::function(&input).map_err(|e| e.to_string())?;
 
         // Then, translate the AST nodes into Cranelift IR.
-        self.translate(params, the_return, stmts)
-            .map_err(|e| e.to_string())?;
+        self.translate(params, the_return, stmts)?;
 
         // Next, declare the function to simplejit. Functions must be declared
         // before they can be called, or defined.
@@ -215,53 +214,53 @@ impl<'a> FunctionTranslator<'a> {
                 self.builder.ins().udiv(lhs, rhs)
             }
 
-            Expr::Eq(lhs, rhs) => self.translate_icmp(IntCC::Equal, lhs, rhs),
-            Expr::Ne(lhs, rhs) => self.translate_icmp(IntCC::NotEqual, lhs, rhs),
-            Expr::Lt(lhs, rhs) => self.translate_icmp(IntCC::SignedLessThan, lhs, rhs),
-            Expr::Le(lhs, rhs) => self.translate_icmp(IntCC::SignedLessThanOrEqual, lhs, rhs),
-            Expr::Gt(lhs, rhs) => self.translate_icmp(IntCC::SignedGreaterThan, lhs, rhs),
-            Expr::Ge(lhs, rhs) => self.translate_icmp(IntCC::SignedGreaterThanOrEqual, lhs, rhs),
+            Expr::Eq(lhs, rhs) => self.translate_icmp(IntCC::Equal, *lhs, *rhs),
+            Expr::Ne(lhs, rhs) => self.translate_icmp(IntCC::NotEqual, *lhs, *rhs),
+            Expr::Lt(lhs, rhs) => self.translate_icmp(IntCC::SignedLessThan, *lhs, *rhs),
+            Expr::Le(lhs, rhs) => self.translate_icmp(IntCC::SignedLessThanOrEqual, *lhs, *rhs),
+            Expr::Gt(lhs, rhs) => self.translate_icmp(IntCC::SignedGreaterThan, *lhs, *rhs),
+            Expr::Ge(lhs, rhs) => self.translate_icmp(IntCC::SignedGreaterThanOrEqual, *lhs, *rhs),
             Expr::Call(name, args) => self.translate_call(name, args),
             Expr::GlobalDataAddr(name) => self.translate_global_data_addr(name),
             Expr::Identifier(name) => {
                 // `use_var` is used to read the value of a variable.
                 let variable = self.variables.get(&name).expect("variable not defined");
                 self.builder.use_var(*variable)
             }
-            Expr::Assign(name, expr) => self.translate_assign(name, expr),
+            Expr::Assign(name, expr) => self.translate_assign(name, *expr),
             Expr::IfElse(condition, then_body, else_body) => {
-                self.translate_if_else(condition, then_body, else_body)
+                self.translate_if_else(*condition, then_body, else_body)
             }
             Expr::WhileLoop(condition, loop_body) => {
-                self.translate_while_loop(condition, loop_body)
+                self.translate_while_loop(*condition, loop_body)
             }
         }
     }
 
-    fn translate_assign(&mut self, name: String, expr: Box<Expr>) -> Value {
+    fn translate_assign(&mut self, name: String, expr: Expr) -> Value {
         // `def_var` is used to write the value of a variable. Note that
         // variables can have multiple definitions. Cranelift will
         // convert them into SSA form for itself automatically.
-        let new_value = self.translate_expr(*expr);
+        let new_value = self.translate_expr(expr);
         let variable = self.variables.get(&name).unwrap();
         self.builder.def_var(*variable, new_value);
         new_value
     }
 
-    fn translate_icmp(&mut self, cmp: IntCC, lhs: Box<Expr>, rhs: Box<Expr>) -> Value {
-        let lhs = self.translate_expr(*lhs);
-        let rhs = self.translate_expr(*rhs);
+    fn translate_icmp(&mut self, cmp: IntCC, lhs: Expr, rhs: Expr) -> Value {
+        let lhs = self.translate_expr(lhs);
+        let rhs = self.translate_expr(rhs);
         let c = self.builder.ins().icmp(cmp, lhs, rhs);
         self.builder.ins().bint(self.int, c)
     }
 
     fn translate_if_else(
         &mut self,
-        condition: Box<Expr>,
+        condition: Expr,
         then_body: Vec<Expr>,
         else_body: Vec<Expr>,
     ) -> Value {
-        let condition_value = self.translate_expr(*condition);
+        let condition_value = self.translate_expr(condition);
 
         let then_block = self.builder.create_block();
         let else_block = self.builder.create_block();
@@ -312,15 +311,15 @@ impl<'a> FunctionTranslator<'a> {
         phi
     }
 
-    fn translate_while_loop(&mut self, condition: Box<Expr>, loop_body: Vec<Expr>) -> Value {
+    fn translate_while_loop(&mut self, condition: Expr, loop_body: Vec<Expr>) -> Value {
         let header_block = self.builder.create_block();
         let body_block = self.builder.create_block();
         let exit_block = self.builder.create_block();
 
         self.builder.ins().jump(header_block, &[]);
         self.builder.switch_to_block(header_block);
 
-        let condition_value = self.translate_expr(*condition);
+        let condition_value = self.translate_expr(condition);
         self.builder.ins().brz(condition_value, exit_block, &[]);
         self.builder.ins().jump(body_block, &[]);