From 2b22cd443e92d94c4ca88f5e80b796ecb91cc790 Mon Sep 17 00:00:00 2001
From: Windel Bouwman <windel@windel.nl>
Date: Mon, 4 Feb 2019 18:18:40 +0100
Subject: [PATCH] Implement clippy thoughts into rustpython_parser

---
 parser/src/ast.rs         |  4 +--
 parser/src/lexer.rs       | 51 +++++++++++++++------------------------
 parser/src/python.lalrpop |  6 ++++-
 3 files changed, 27 insertions(+), 34 deletions(-)

diff --git a/parser/src/ast.rs b/parser/src/ast.rs
index 6a4a6f409..d28f69e2f 100644
--- a/parser/src/ast.rs
+++ b/parser/src/ast.rs
@@ -65,9 +65,9 @@ pub enum Statement {
         value: Expression,
     },
     AugAssign {
-        target: Expression,
+        target: Box<Expression>,
         op: Operator,
-        value: Expression,
+        value: Box<Expression>,
     },
     Expression {
         expression: Expression,
diff --git a/parser/src/lexer.rs b/parser/src/lexer.rs
index cf611e8a1..0d721f7d1 100644
--- a/parser/src/lexer.rs
+++ b/parser/src/lexer.rs
@@ -64,10 +64,7 @@ pub struct Location {
 
 impl Location {
     pub fn new(row: usize, column: usize) -> Self {
-        Location {
-            row: row,
-            column: column,
-        }
+        Location { row, column }
     }
 
     pub fn get_row(&self) -> usize {
@@ -126,8 +123,7 @@ pub type Spanned<Tok> = Result<(Location, Tok, Location), LexicalError>;
 pub fn make_tokenizer<'a>(source: &'a str) -> impl Iterator<Item = Spanned<Tok>> + 'a {
     let nlh = NewlineHandler::new(source.chars());
     let lch = LineContinationHandler::new(nlh);
-    let lexer = Lexer::new(lch);
-    lexer
+    Lexer::new(lch)
 }
 
 // The newline handler is an iterator which collapses different newline
@@ -144,7 +140,7 @@ where
 {
     pub fn new(source: T) -> Self {
         let mut nlh = NewlineHandler {
-            source: source,
+            source,
             chr0: None,
             chr1: None,
         };
@@ -200,7 +196,7 @@ where
 {
     pub fn new(source: T) -> Self {
         let mut nlh = LineContinationHandler {
-            source: source,
+            source,
             chr0: None,
             chr1: None,
         };
@@ -313,7 +309,7 @@ where
         if keywords.contains_key(&name) {
             Ok((start_pos, keywords.remove(&name).unwrap(), end_pos))
         } else {
-            Ok((start_pos, Tok::Name { name: name }, end_pos))
+            Ok((start_pos, Tok::Name { name }, end_pos))
         }
     }
 
@@ -358,7 +354,7 @@ where
 
         let end_pos = self.get_pos();
         let value = BigInt::from_str_radix(&value_text, radix).unwrap();
-        Ok((start_pos, Tok::Int { value: value }, end_pos))
+        Ok((start_pos, Tok::Int { value }, end_pos))
     }
 
     fn lex_normal_number(&mut self) -> Spanned<Tok> {
@@ -410,7 +406,7 @@ where
                 ))
             } else {
                 let end_pos = self.get_pos();
-                Ok((start_pos, Tok::Float { value: value }, end_pos))
+                Ok((start_pos, Tok::Float { value }, end_pos))
             }
         } else {
             // Parse trailing 'j':
@@ -418,18 +414,11 @@ where
                 self.next_char();
                 let end_pos = self.get_pos();
                 let imag = f64::from_str(&value_text).unwrap();
-                Ok((
-                    start_pos,
-                    Tok::Complex {
-                        real: 0.0,
-                        imag: imag,
-                    },
-                    end_pos,
-                ))
+                Ok((start_pos, Tok::Complex { real: 0.0, imag }, end_pos))
             } else {
                 let end_pos = self.get_pos();
                 let value = value_text.parse::<BigInt>().unwrap();
-                Ok((start_pos, Tok::Int { value: value }, end_pos))
+                Ok((start_pos, Tok::Int { value }, end_pos))
             }
         }
     }
@@ -548,33 +537,33 @@ where
             }
         };
 
-        return Ok((start_pos, tok, end_pos));
+        Ok((start_pos, tok, end_pos))
     }
 
     fn is_char(&self) -> bool {
         match self.chr0 {
-            Some('a'...'z') | Some('A'...'Z') | Some('_') | Some('0'...'9') => return true,
-            _ => return false,
+            Some('a'...'z') | Some('A'...'Z') | Some('_') | Some('0'...'9') => true,
+            _ => false,
         }
     }
 
     fn is_number(&self, radix: u32) -> bool {
         match radix {
             2 => match self.chr0 {
-                Some('0'...'1') => return true,
-                _ => return false,
+                Some('0'...'1') => true,
+                _ => false,
             },
             8 => match self.chr0 {
-                Some('0'...'7') => return true,
-                _ => return false,
+                Some('0'...'7') => true,
+                _ => false,
             },
             10 => match self.chr0 {
-                Some('0'...'9') => return true,
-                _ => return false,
+                Some('0'...'9') => true,
+                _ => false,
             },
             16 => match self.chr0 {
-                Some('0'...'9') | Some('a'...'f') | Some('A'...'F') => return true,
-                _ => return false,
+                Some('0'...'9') | Some('a'...'f') | Some('A'...'F') => true,
+                _ => false,
             },
             x => unimplemented!("Radix not implemented: {}", x),
         }
diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
index 4d126ee17..07b6ec3b6 100644
--- a/parser/src/python.lalrpop
+++ b/parser/src/python.lalrpop
@@ -105,7 +105,11 @@ ExpressionStatement: ast::LocatedStatement = {
         let rhs = e2.into_iter().next().unwrap();
         ast::LocatedStatement {
             location: loc,
-            node: ast::Statement::AugAssign { target: expr, op: op, value: rhs },
+            node: ast::Statement::AugAssign {
+                target: Box::new(expr),
+                op,
+                value: Box::new(rhs)
+            },
         }
     },
 };