Fix new rustc and clippy warnings

Author: Colecf

src-rs/dep.rs

@@ -283,26 +283,28 @@ impl RuleMerger {
             );
         }
 
-        if let Some(primary_rule) = &mut self.primary_rule {
-            if !r.cmds.is_empty() && !is_suffix_rule(&output) && !r.is_double_colon {
-                if FLAGS.werror_overriding_commands {
-                    error_loc!(
-                        r.cmd_loc.as_ref(),
-                        "*** overriding commands for target `{output}', previously defined at {}",
-                        primary_rule.cmd_loc.clone().unwrap_or_default()
-                    );
-                } else {
-                    warn_loc!(
-                        r.cmd_loc.as_ref(),
-                        "warning: overriding commands for target `{output}'"
-                    );
-                    warn_loc!(
-                        primary_rule.cmd_loc.as_ref(),
-                        "warning: ignoring old commands for target `{output}'"
-                    )
-                }
-                *primary_rule = r.clone();
+        if let Some(primary_rule) = &mut self.primary_rule
+            && !r.cmds.is_empty()
+            && !is_suffix_rule(&output)
+            && !r.is_double_colon
+        {
+            if FLAGS.werror_overriding_commands {
+                error_loc!(
+                    r.cmd_loc.as_ref(),
+                    "*** overriding commands for target `{output}', previously defined at {}",
+                    primary_rule.cmd_loc.clone().unwrap_or_default()
+                );
+            } else {
+                warn_loc!(
+                    r.cmd_loc.as_ref(),
+                    "warning: overriding commands for target `{output}'"
+                );
+                warn_loc!(
+                    primary_rule.cmd_loc.as_ref(),
+                    "warning: ignoring old commands for target `{output}'"
+                )
             }
+            *primary_rule = r.clone();
         }
         if self.primary_rule.is_none() && !r.cmds.is_empty() {
             self.primary_rule = Some(r.clone());
@@ -329,10 +331,10 @@ impl RuleMerger {
 
     fn fill_dep_node_loc(&self, r: &Rule, n: &mut DepNode) {
         n.loc = Some(r.loc.clone());
-        if !r.cmds.is_empty() {
-            if let Some(cmd_loc) = r.cmd_loc.clone() {
-                n.loc = Some(cmd_loc);
-            }
+        if !r.cmds.is_empty()
+            && let Some(cmd_loc) = r.cmd_loc.clone()
+        {
+            n.loc = Some(cmd_loc);
         }
     }
 
@@ -355,10 +357,10 @@ impl RuleMerger {
         }
 
         for r in &self.rules {
-            if let Some(primary_rule) = &self.primary_rule {
-                if Arc::ptr_eq(r, primary_rule) {
-                    continue;
-                }
+            if let Some(primary_rule) = &self.primary_rule
+                && Arc::ptr_eq(r, primary_rule)
+            {
+                continue;
             }
             self.fill_dep_node_from_rule(output, r, &mut n);
             if n.loc.is_none() {
@@ -761,18 +763,18 @@ impl<'a> DepBuilder<'a> {
     fn pick_rule(&mut self, output: Symbol, n: &Arc<Mutex<DepNode>>) -> Option<PickedRuleInfo> {
         let rule_merger = self.lookup_rule_merger(output);
         let vars = self.lookup_rule_vars(output);
-        if let Some(rule_merger) = &rule_merger {
-            if rule_merger.lock().primary_rule.is_some() {
-                let mut vars = vars;
-                for (sym, _) in &rule_merger.lock().implicit_outputs {
-                    vars = self.merge_implicit_rule_vars(*sym, vars);
-                }
-                return Some(PickedRuleInfo {
-                    merger: Some(rule_merger.clone()),
-                    pattern_rule: None,
-                    vars,
-                });
+        if let Some(rule_merger) = &rule_merger
+            && rule_merger.lock().primary_rule.is_some()
+        {
+            let mut vars = vars;
+            for (sym, _) in &rule_merger.lock().implicit_outputs {
+                vars = self.merge_implicit_rule_vars(*sym, vars);
             }
+            return Some(PickedRuleInfo {
+                merger: Some(rule_merger.clone()),
+                pattern_rule: None,
+                vars,
+            });
         }
 
         let irules = self.implicit_rules.get(&output.as_bytes());
@@ -891,17 +893,17 @@ impl<'a> DepBuilder<'a> {
         let Some(mut picked_rule_info) = self.pick_rule(output, &n) else {
             return Ok(n);
         };
-        if let Some(merger) = &picked_rule_info.merger {
-            if merger.lock().parent.is_some() {
-                output = merger.lock().parent_sym.unwrap();
-                self.done.insert(output, n.clone());
-                n.lock().output = output;
-                let Some(new_picked_rule_info) = self.pick_rule(output, &n) else {
-                    return Ok(n);
-                };
-                // Update the picked_rule_info with the new values
-                picked_rule_info = new_picked_rule_info;
-            }
+        if let Some(merger) = &picked_rule_info.merger
+            && merger.lock().parent.is_some()
+        {
+            output = merger.lock().parent_sym.unwrap();
+            self.done.insert(output, n.clone());
+            n.lock().output = output;
+            let Some(new_picked_rule_info) = self.pick_rule(output, &n) else {
+                return Ok(n);
+            };
+            // Update the picked_rule_info with the new values
+            picked_rule_info = new_picked_rule_info;
         }
         let output_str = output.as_bytes();
 

src-rs/eval.rs

@@ -217,10 +217,10 @@ impl IncludeGraph {
         if frame.frame_type == FrameType::Parse {
             self.nodes.entry(frame.name.clone()).or_default();
 
-            if let Some(parent_frame) = self.include_stack.last() {
-                if let Some(parent_node) = self.nodes.get_mut(&parent_frame.name) {
-                    parent_node.includes.insert(frame.name.clone());
-                }
+            if let Some(parent_frame) = self.include_stack.last()
+                && let Some(parent_node) = self.nodes.get_mut(&parent_frame.name)
+            {
+                parent_node.includes.insert(frame.name.clone());
             }
 
             self.include_stack.push(frame.clone());
@@ -464,10 +464,8 @@ impl Evaluator {
         if let Some(prev) = prev {
             let prev = prev.read();
             prev.used(self, &lhs)?;
-            if needs_assign {
-                if let Some(deprecated) = &prev.deprecated {
-                    result.write().deprecated = Some(deprecated.clone());
-                }
+            if needs_assign && let Some(deprecated) = &prev.deprecated {
+                result.write().deprecated = Some(deprecated.clone());
             }
         }
 
@@ -686,17 +684,11 @@ impl Evaluator {
 
         // If variable name is not empty, we have rule- or target-specific
         // variable assignment.
-        if separator == Some(b'=') {
-            if let Some(separator_pos) = separator_pos {
-                if separator_pos > 0 {
-                    return self.eval_rule_specific_assign(
-                        &targets,
-                        stmt,
-                        &after_targets,
-                        separator_pos,
-                    );
-                }
-            }
+        if separator == Some(b'=')
+            && let Some(separator_pos) = separator_pos
+            && separator_pos > 0
+        {
+            return self.eval_rule_specific_assign(&targets, stmt, &after_targets, separator_pos);
         }
 
         if separator_pos == Some(0) {
@@ -914,17 +906,17 @@ impl Evaluator {
         for tok in word_scanner(&exports) {
             let equal_index = memchr(b'=', tok);
             let lhs;
-            if equal_index.is_none() {
-                lhs = tok;
-            } else if equal_index == Some(0)
+            if equal_index == Some(0)
                 || (equal_index == Some(1)
                     && (tok.starts_with(b":") || tok.starts_with(b"?") || tok.starts_with(b"+")))
             {
                 // Do not export tokens after an assignment.
                 break;
-            } else {
-                let assign = parse_assign_statement(tok, equal_index.unwrap());
+            } else if let Some(equal_index) = equal_index {
+                let assign = parse_assign_statement(tok, equal_index);
                 lhs = assign.lhs;
+            } else {
+                lhs = tok;
             }
             let sym = intern(exports.slice_ref(lhs));
             self.exports.insert(sym, stmt.is_export);

src-rs/expr.rs

@@ -331,15 +331,15 @@ fn parse_dollar(loc: &mut Loc, s: Bytes, end_paren: bool) -> Result<(usize, Arc<
         if t.first() == Some(&cp) || (end_paren && t.is_empty() && cp == b')') {
             if let Value::Literal(_, lit) = &*vname {
                 let sym = intern(lit.clone());
-                if FLAGS.enable_kati_warnings {
-                    if let Some(found) = sym.to_string().find([' ', '(', '{']) {
-                        kati_warn_loc!(
-                            Some(&start_loc),
-                            "*warning*: variable lookup with '{}': {}",
-                            &sym.to_string()[found..found + 1],
-                            String::from_utf8_lossy(&s)
-                        )
-                    }
+                if FLAGS.enable_kati_warnings
+                    && let Some(found) = sym.to_string().find([' ', '(', '{'])
+                {
+                    kati_warn_loc!(
+                        Some(&start_loc),
+                        "*warning*: variable lookup with '{}': {}",
+                        &sym.to_string()[found..found + 1],
+                        String::from_utf8_lossy(&s)
+                    )
                 }
                 return Ok((i + 1, Arc::new(Value::SymRef(start_loc, sym))));
             }
@@ -477,10 +477,11 @@ pub fn parse_expr_impl_ext(
 
         let remaining = &s[i..];
         let c = remaining[0];
-        if let Some(terms) = terms {
-            if save_paren.is_none() && terms[terms_ignored..].contains(&c) {
-                break;
-            }
+        if let Some(terms) = terms
+            && save_paren.is_none()
+            && terms[terms_ignored..].contains(&c)
+        {
+            break;
         }
 
         // Handle a comment
@@ -515,15 +516,15 @@ pub fn parse_expr_impl_ext(
                 continue;
             }
 
-            if let Some(terms) = terms {
-                if terms[terms_ignored..].contains(&remaining[1]) {
-                    let val = Arc::new(Value::Literal(None, Bytes::from_static(b"$")));
-                    if list.is_empty() {
-                        return Ok((i + 1, val));
-                    }
-                    list.push(val);
-                    return Ok((i + 1, Arc::new(Value::List(Some(item_loc), list))));
+            if let Some(terms) = terms
+                && terms[terms_ignored..].contains(&remaining[1])
+            {
+                let val = Arc::new(Value::Literal(None, Bytes::from_static(b"$")));
+                if list.is_empty() {
+                    return Ok((i + 1, val));
                 }
+                list.push(val);
+                return Ok((i + 1, Arc::new(Value::List(Some(item_loc), list))));
             }
 
             let (n, v) = parse_dollar(loc, s.slice(i..), end_paren)?;
@@ -572,10 +573,10 @@ pub fn parse_expr_impl_ext(
             }
             if n == b'\r' || n == b'\n' {
                 loc.line += 1;
-                if let Some(terms) = terms {
-                    if terms.contains(&b' ') {
-                        break;
-                    }
+                if let Some(terms) = terms
+                    && terms.contains(&b' ')
+                {
+                    break;
                 }
                 if i > b {
                     list.push(Arc::new(Value::Literal(

src-rs/find.rs

@@ -199,10 +199,10 @@ impl DirentNode {
         d: i32,
         out: &mut Vec<Vec<u8>>,
     ) {
-        if let Some(print_cond) = &fc.print_cond {
-            if !print_cond.is_true(path, typ) {
-                return;
-            }
+        if let Some(print_cond) = &fc.print_cond
+            && !print_cond.is_true(path, typ)
+        {
+            return;
         }
         if d < fc.mindepth {
             return;
@@ -1155,11 +1155,11 @@ impl FindEmulator {
         loc: &Loc,
         out: &mut BytesMut,
     ) -> Result<bool> {
-        if let Some(chdir) = &fc.chdir {
-            if !Self::can_handle(chdir) {
-                log!("FindEmulator: Cannot handle chdir ({chdir:?}): {cmd:?}");
-                return Ok(false);
-            }
+        if let Some(chdir) = &fc.chdir
+            && !Self::can_handle(chdir)
+        {
+            log!("FindEmulator: Cannot handle chdir ({chdir:?}): {cmd:?}");
+            return Ok(false);
         }
 
         if let Some(testdir) = &fc.testdir {

src-rs/func.rs

@@ -51,7 +51,6 @@ use crate::{
 
 type MakeFuncImpl = fn(&[Arc<Value>], &mut Evaluator, &mut dyn BufMut) -> Result<()>;
 
-#[derive(PartialEq)]
 pub struct FuncInfo {
     pub name: &'static [u8],
     pub func: MakeFuncImpl,
@@ -63,6 +62,13 @@ pub struct FuncInfo {
     pub trim_right_space_1st: bool,
 }
 
+// Function pointers are not comparable, so just compare by name
+impl PartialEq for FuncInfo {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
 impl Debug for FuncInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Func({})", String::from_utf8_lossy(self.name))
@@ -556,12 +562,11 @@ fn shell_func_impl(
 ) -> Result<(i32, Bytes, Option<FindCommand>)> {
     log!("ShellFunc: {:?}", cmd);
 
-    if FLAGS.use_find_emulator {
-        if let Some(fc) = crate::find::parse(cmd)? {
-            if let Some(out) = crate::find::find(cmd, &fc, loc)? {
-                return Ok((0, out, Some(fc)));
-            }
-        }
+    if FLAGS.use_find_emulator
+        && let Some(fc) = crate::find::parse(cmd)?
+        && let Some(out) = crate::find::find(cmd, &fc, loc)?
+    {
+        return Ok((0, out, Some(fc)));
     }
 
     collect_stats_with_slow_report!("func shell time", OsStr::from_bytes(cmd));

src-rs/main.rs

@@ -363,11 +363,11 @@ fn main() {
         }
     }
 
-    if let Some(working_dir) = &FLAGS.working_dir {
-        if let Err(e) = std::env::set_current_dir(working_dir) {
-            eprintln!("*** {}: {}", working_dir.to_string_lossy(), e);
-            std::process::exit(1);
-        }
+    if let Some(working_dir) = &FLAGS.working_dir
+        && let Err(e) = std::env::set_current_dir(working_dir)
+    {
+        eprintln!("*** {}: {}", working_dir.to_string_lossy(), e);
+        std::process::exit(1);
     }
     let orig_args = std::env::args_os()
         .collect::<Vec<OsString>>()

src-rs/parser.rs

@@ -668,7 +668,7 @@ pub struct ParsedAssign<'a> {
     pub rhs: &'a [u8],
     pub op: AssignOp,
 }
-pub fn parse_assign_statement(line: &[u8], sep: usize) -> ParsedAssign {
+pub fn parse_assign_statement(line: &[u8], sep: usize) -> ParsedAssign<'_> {
     assert!(sep != 0);
     let mut op = AssignOp::Eq;
     let mut lhs = &line[..sep];