fix clippy lints

More to come

Author: Eli Rosenthal

src/arena.rs

@@ -16,10 +16,10 @@ pub struct Arena(bumpalo::Bump);
 pub type Vec<'a, T> = bumpalo::collections::Vec<'a, T>;
 
 impl Arena {
-    pub fn vec_with_capacity<'a, T>(&'a self, capacity: usize) -> Vec<'a, T> {
+    pub fn vec_with_capacity<T>(&self, capacity: usize) -> Vec<T> {
         Vec::with_capacity_in(capacity, &self.0)
     }
-    pub fn new_vec<'a, T>(&'a self) -> Vec<'a, T> {
+    pub fn new_vec<T>(&self) -> Vec<T> {
         Vec::new_in(&self.0)
     }
     pub fn new_vec_from_slice<'a, T: Clone>(&'a self, elts: &[T]) -> Vec<'a, T> {

src/ast.rs

@@ -78,7 +78,7 @@ fn parse_header<'a, 'b, I: From<&'b str> + Clone>(
 ) {
     use {self::Expr::*, Stmt::*};
     // Pick an illegal frawk identifier.
-    const LOOP_VAR: &'static str = "--";
+    const LOOP_VAR: &str = "--";
     // Append the following to begin:
     // if (getline > 0) {
     //  for (LOOP_VAR=1; LOOP_VAR <= NF; ++LOOP_VAR)
@@ -185,7 +185,7 @@ impl<'a, 'b, I: From<&'b str> + Clone> Prog<'a, 'b, I> {
         }
 
         // Set argc, argv
-        if self.argv.len() > 0 {
+        if !self.argv.is_empty() {
             begin.push(arena.alloc(Expr(arena.alloc(Assign(
                 arena.alloc(Var("ARGC".into())),
                 arena.alloc(ILit(self.argv.len() as i64)),
@@ -282,23 +282,23 @@ impl<'a, 'b, I: From<&'b str> + Clone> Prog<'a, 'b, I> {
             }
         }
 
-        if self.end.len() > 0 || self.prepare.len() > 0 || inner.len() > init_len {
+        if !self.end.is_empty() || !self.prepare.is_empty() || inner.len() > init_len {
             // Wrap the whole thing in a while((getline) > 0) { } statement.
             let main_portion = arena.alloc(While(
                 /*is_toplevel=*/ true,
                 arena.alloc(Binop(GT, arena.alloc(ReadStdin), arena.alloc(ILit(0)))),
                 arena.alloc(Block(inner)),
             ));
-            main_loop = Some(if self.prepare.len() > 0 {
+            main_loop = Some(if self.prepare.is_empty() {
+                main_portion
+            } else {
                 let mut block = arena.vec_with_capacity(self.prepare.len() + 1);
                 block.push(main_portion);
                 block.extend(self.prepare.iter().cloned());
                 arena.alloc(Stmt::Block(block))
-            } else {
-                main_portion
             });
         }
-        if self.end.len() > 0 {
+        if !self.end.is_empty() {
             end = Some(arena.alloc(Stmt::Block(self.end.clone())));
         }
         match self.stage {
@@ -307,10 +307,10 @@ impl<'a, 'b, I: From<&'b str> + Clone> Prog<'a, 'b, I> {
                 Stage::Main(arena.alloc(Stmt::Block(begin)))
             }
             Stage::Par { .. } => Stage::Par {
-                begin: if begin.len() > 0 {
-                    Some(arena.alloc(Stmt::Block(begin)))
-                } else {
+                begin: if begin.is_empty() {
                     None
+                } else {
+                    Some(arena.alloc(Stmt::Block(begin)))
                 },
                 main_loop,
                 end,

src/builtins.rs

@@ -359,7 +359,7 @@ impl Function {
                     (Str, Str) => smallvec![Str; 2],
                     (Int, Int) | (Null, Int) | (Int, Null) | (Null, Null) => smallvec![Int; 2],
                     (_, Str) | (Str, _) | (Float, _) | (_, Float) => smallvec![Float; 2],
-                    _ => return err!("invalid input spec for comparison op: {:?}", &incoming[..]),
+                    _ => return err!("invalid input spec for comparison op: {:?}", incoming),
                 },
                 Int,
             ),
@@ -370,12 +370,12 @@ impl Function {
             Contains => match incoming[0] {
                 MapIntInt | MapIntStr | MapIntFloat => (smallvec![incoming[0], Int], Int),
                 MapStrInt | MapStrStr | MapStrFloat => (smallvec![incoming[0], Str], Int),
-                _ => return err!("invalid input spec fo Contains: {:?}", &incoming[..]),
+                _ => return err!("invalid input spec fo Contains: {:?}", incoming),
             },
             Delete => match incoming[0] {
                 MapIntInt | MapIntStr | MapIntFloat => (smallvec![incoming[0], Int], Int),
                 MapStrInt | MapStrStr | MapStrFloat => (smallvec![incoming[0], Str], Int),
-                _ => return err!("invalid input spec fo Delete: {:?}", &incoming[..]),
+                _ => return err!("invalid input spec fo Delete: {:?}", incoming),
             },
             IncMap => {
                 let map = incoming[0];
@@ -396,10 +396,7 @@ impl Function {
                 if incoming.len() == 1 && incoming[0].is_array() {
                     (smallvec![incoming[0]], Int)
                 } else {
-                    return err!(
-                        "invalid input spec for delete (of a map): {:?}",
-                        &incoming[..]
-                    );
+                    return err!("invalid input spec for delete (of a map): {:?}", incoming);
                 }
             }
             Srand => (smallvec![Int], Int),
@@ -437,7 +434,7 @@ impl Function {
                 if let MapIntStr | MapStrStr = incoming[1] {
                     (smallvec![Str, incoming[1], Str], Int)
                 } else {
-                    return err!("invalid input spec for split: {:?}", &incoming[..]);
+                    return err!("invalid input spec for split: {:?}", incoming);
                 }
             }
             JoinCols => (smallvec![Int, Int, Str], Str),
@@ -589,7 +586,7 @@ impl<'a> Variables<'a> {
 
     pub fn store_int(&mut self, var: Variable, i: Int) -> Result<()> {
         use Variable::*;
-        Ok(match var {
+        match var {
             ARGC => self.argc = i,
             NF => self.nf = i,
             NR => self.nr = i,
@@ -598,7 +595,8 @@ impl<'a> Variables<'a> {
             RLENGTH => self.rlength = i,
             PID => self.pid = i,
             FI | ORS | OFS | FS | RS | FILENAME | ARGV => return err!("var {} not an int", var),
-        })
+        }
+        Ok(())
     }
 
     pub fn load_str(&self, var: Variable) -> Result<Str<'a>> {
@@ -617,7 +615,7 @@ impl<'a> Variables<'a> {
 
     pub fn store_str(&mut self, var: Variable, s: Str<'a>) -> Result<()> {
         use Variable::*;
-        Ok(match var {
+        match var {
             FS => self.fs = s,
             OFS => self.ofs = s,
             ORS => self.ors = s,
@@ -626,7 +624,8 @@ impl<'a> Variables<'a> {
             FI | PID | ARGC | ARGV | NF | NR | FNR | RSTART | RLENGTH => {
                 return err!("var {} not a string", var)
             }
-        })
+        };
+        Ok(())
     }
 
     pub fn load_intmap(&self, var: Variable) -> Result<IntMap<Str<'a>>> {
@@ -642,7 +641,10 @@ impl<'a> Variables<'a> {
     pub fn store_intmap(&mut self, var: Variable, m: IntMap<Str<'a>>) -> Result<()> {
         use Variable::*;
         match var {
-            ARGV => Ok(self.argv = m),
+            ARGV => {
+                self.argv = m;
+                Ok(())
+            }
             FI | PID | ORS | OFS | ARGC | NF | NR | FNR | FS | RS | FILENAME | RSTART | RLENGTH => {
                 err!("var {} is not an int-keyed map", var)
             }