ran clippy

Cargo.toml

@@ -19,4 +19,3 @@ libc = "0.2.65"
 [build-dependencies]
 cc = "*"
 bindgen = "0.52.0"
-

src/lexer.rs

@@ -35,7 +35,7 @@ pub enum Token {
 impl Token {
     pub fn get_string(self) -> String {
         match self {
-            Token::Ident(name) => return name,
+            Token::Ident(name) => name,
             _ => unimplemented!(),
         }
     }

src/main.rs

@@ -5,7 +5,7 @@ mod parser;
 use std::env;
 use std::fs;
 
-const USAGE: &'static str = "
+const USAGE: &str = "
 Usage: cargo run SOURCE_FILE OUTPUT_FILE
 Options:
      

src/parser.rs

@@ -21,25 +21,15 @@ impl Program {
 
     fn get_tok_precedence(&mut self) -> isize {
         match self.cur_token {
-            Token::Plus => {
-                return 20;
-            }
-            Token::Hyphen => {
-                return 20;
-            }
-            Token::Asterisk => {
-                return 40;
-            }
-            Token::LessThan => {
-                return 10;
-            }
-            _ => {
-                return -1;
-            }
+            Token::Plus => 20,
+            Token::Hyphen => 20,
+            Token::Asterisk => 40,
+            Token::LessThan => 10,
+            _ => -1,
         }
     }
 
-    pub fn new(file_name: &String, input: &str) -> Self {
+    pub fn new(file_name: &str, input: &str) -> Self {
         let tokens = lexer::tokenize(input);
 
         Self {
@@ -75,9 +65,7 @@ impl Program {
         self.get_next_token();
         let v = self.parse_expression();
 
-        if v.is_none() {
-            return None;
-        }
+        v.as_ref()?;
 
         if self.cur_token != Token::CloseBracket {
             return log_error("expected ')'".to_owned());
@@ -135,18 +123,10 @@ impl Program {
     pub fn parse_primary(&mut self) -> Option<Box<ExprAST>> {
         let k = self.cur_token.clone();
         match k {
-            Token::Ident(e) => {
-                return self.parse_identifier_expr(e.clone());
-            }
-            Token::IntNumber(num) => {
-                return self.parse_number_expr(num as f64);
-            }
-            Token::FloatNumber(num) => {
-                return self.parse_number_expr(num);
-            }
-            Token::OpenCurly => {
-                return self.parse_paren_expr();
-            }
+            Token::Ident(e) => self.parse_identifier_expr(e),
+            Token::IntNumber(num) => self.parse_number_expr(num as f64),
+            Token::FloatNumber(num) => self.parse_number_expr(num),
+            Token::OpenCurly => self.parse_paren_expr(),
             _ => {
                 log_error("unknown token when expecting an expression".to_owned());
                 None
@@ -157,11 +137,9 @@ impl Program {
     pub fn parse_expression(&mut self) -> Option<Box<ExprAST>> {
         let lhs = self.parse_primary();
 
-        if lhs.is_none() {
-            return None;
-        }
+        lhs.as_ref()?;
 
-        return self.parse_bin_op_rhs(0, lhs);
+        self.parse_bin_op_rhs(0, lhs)
     }
 
     pub fn parse_bin_op_rhs(
@@ -179,18 +157,14 @@ impl Program {
             self.get_next_token();
 
             let mut rhs = self.parse_primary();
-            if rhs.is_none() {
-                return None;
-            }
+            rhs.as_ref()?;
 
             let next_prec = self.get_tok_precedence();
 
             if tok_prec < next_prec {
                 rhs = self.parse_bin_op_rhs(tok_prec + 1, rhs);
 
-                if rhs.is_none() {
-                    return None;
-                }
+                rhs.as_ref()?;
             }
 
             lhs = Some(Box::new(BinaryExpr(BinaryExprAST {
@@ -230,25 +204,21 @@ impl Program {
         self.get_next_token();
 
         Some(Box::new(PrototypeAST {
-            name: fn_name.to_owned(),
+            name: fn_name,
             args: arg_names,
         }))
     }
 
     pub fn parse_definition(&mut self) -> Option<Box<FunctionAST>> {
         self.get_next_token();
         let proto = self.parse_prototype();
-        if proto.is_none() {
-            return None;
-        }
+        proto.as_ref()?;
 
         match self.parse_expression() {
-            Some(e) => {
-                return Some(Box::new(FunctionAST {
-                    prototype: proto.unwrap(),
-                    body: e,
-                }));
-            }
+            Some(e) => Some(Box::new(FunctionAST {
+                prototype: proto.unwrap(),
+                body: e,
+            })),
             _ => None,
         }
     }