style: fix clippy warnings.

With the change to edition 2024 clippy finds a bunch of new warnings. Most of them are related to chained `if let` statements.

Author: plusvic

cli/src/commands/deps.rs

@@ -85,7 +85,7 @@ pub fn exec_deps(args: &ArgMatches) -> anyhow::Result<()> {
 
     for dep in dep_tree.iter() {
         let mut output = String::new();
-        write_tree(&mut output, &dep)?;
+        write_tree(&mut output, dep)?;
         println!("{output}");
     }
 
@@ -100,7 +100,7 @@ fn generate_dep_tree(
 
     for (rule, deps) in dep_map.iter() {
         if requested_rules.is_empty() || requested_rules.contains(rule) {
-            nodes.push(tree_for_rule(rule, &deps, &dep_map));
+            nodes.push(tree_for_rule(rule, deps, dep_map));
         }
     }
 

cli/src/commands/mod.rs

@@ -354,15 +354,14 @@ impl Component for CompileState {
     ) -> anyhow::Result<Lines> {
         let mut lines = Lines::new();
 
-        if mode == superconsole::DrawMode::Normal {
-            if let Some(file) = &self.file_in_progress {
+        if mode == superconsole::DrawMode::Normal
+            && let Some(file) = &self.file_in_progress {
                 lines.push(Line::from_iter([Span::new_unstyled(format!(
                     "{} {}...",
                     "Compiling".paint(Green).bold(),
                     file.display(),
                 ))?]));
             }
-        }
 
         Ok(lines)
     }

cli/src/commands/scan.rs

@@ -11,7 +11,6 @@ use clap::{
     Arg, ArgAction, ArgMatches, Command, ValueEnum, arg, value_parser,
 };
 use crossbeam::channel::Sender;
-use dunce;
 use itertools::Itertools;
 use superconsole::style::Stylize;
 use superconsole::{Component, Line, Lines, Span};
@@ -436,11 +435,10 @@ pub fn exec_scan(args: &ArgMatches, config: &Config) -> anyhow::Result<()> {
             let _ = output.send(Message::Error(msg));
 
             // In case of timeout walk is aborted.
-            if let Ok(scan_err) = err.downcast::<ScanError>() {
-                if matches!(scan_err, ScanError::Timeout) {
+            if let Ok(scan_err) = err.downcast::<ScanError>()
+                && matches!(scan_err, ScanError::Timeout) {
                     return Err(scan_err.into());
                 }
-            }
 
             Ok(())
         },
@@ -756,14 +754,13 @@ mod output_handler {
             let mut result = false;
 
             for matching_rule in scan_results {
-                if let Some(ref only_tag) = self.output_options.only_tag {
-                    if !matching_rule
+                if let Some(ref only_tag) = self.output_options.only_tag
+                    && !matching_rule
                         .tags()
                         .any(|tag| tag.identifier() == only_tag)
                     {
                         continue;
                     }
-                }
 
                 result = true;
 
@@ -1066,7 +1063,7 @@ mod output_handler {
             scan_results: &mut dyn ExactSizeIterator<Item = Rule>,
             _output: &Sender<Message>,
         ) -> bool {
-            let path = dunce::canonicalize(&file_path)
+            let path = dunce::canonicalize(file_path)
                 .ok()
                 .as_ref()
                 .and_then(|absolute| absolute.to_str())

cli/src/walk.rs

@@ -155,11 +155,10 @@ impl<'a> Walker<'a> {
             self.walk_file_list(f, e)
         } else {
             if metadata.is_file() {
-                if self.pass_metadata_filter(metadata) {
-                    if let Err(err) = f(self.path) {
+                if self.pass_metadata_filter(metadata)
+                    && let Err(err) = f(self.path) {
                         return e(err);
-                    }
-                };
+                    };
                 return Ok(());
             }
             self.walk_dir(f, e)
@@ -185,11 +184,10 @@ impl<'a> Walker<'a> {
                     Err(err) => return Err(err),
                 },
             };
-            if self.pass_metadata_filter(metadata) {
-                if let Err(err) = f(&path) {
+            if self.pass_metadata_filter(metadata)
+                && let Err(err) = f(&path) {
                     e(err)?
                 }
-            }
         }
 
         Ok(())
@@ -246,11 +244,10 @@ impl<'a> Walker<'a> {
 
             match entry.metadata() {
                 Ok(metadata) => {
-                    if self.pass_metadata_filter(metadata) {
-                        if let Err(err) = f(entry.path()) {
+                    if self.pass_metadata_filter(metadata)
+                        && let Err(err) = f(entry.path()) {
                             e(err)?
                         }
-                    }
                 }
                 Err(err) => e(err.into())?,
             }
@@ -455,12 +452,11 @@ impl<'a> ParWalker<'a> {
                             path.to_path_buf(),
                             &mut per_thread_obj,
                         );
-                        if let Err(err) = res {
-                            if error(err, &msg_send).is_err() {
+                        if let Err(err) = res
+                            && error(err, &msg_send).is_err() {
                                 let _ = msg_send.send(Message::Abort);
                                 break;
                             }
-                        }
                     }
                     finalize(&per_thread_obj, &msg_send);
                 }));
@@ -490,11 +486,10 @@ impl<'a> ParWalker<'a> {
                     },
                 );
 
-                if let Err(err) = res {
-                    if error(err, &msg_send).is_err() {
+                if let Err(err) = res
+                    && error(err, &msg_send).is_err() {
                         let _ = msg_send.send(Message::Abort);
                     }
-                }
             }));
 
             let mut console = if cfg!(feature = "logging") {
@@ -594,12 +589,11 @@ fn output_messages<S>(
             Err(RecvTimeoutError::Timeout) => {}
         }
 
-        if let Some(console) = console.as_mut() {
-            if Instant::elapsed(&last_render) > render_period {
+        if let Some(console) = console.as_mut()
+            && Instant::elapsed(&last_render) > render_period {
                 console.render(state.as_ref()).unwrap();
                 last_render = Instant::now();
             }
-        }
     }
 }
 

fmt/src/lib.rs

@@ -918,9 +918,9 @@ impl Formatter {
             };
 
         let tokens = AddIndentation::new(tokens, self.indentation);
-        let tokens = RemoveTrailingSpaces::new(tokens);
+        
 
-        tokens
+        RemoveTrailingSpaces::new(tokens)
     }
 
     /// Indents the sections (meta, strings, condition) of a rule one level up.

fmt/src/processor/mod.rs

@@ -411,11 +411,10 @@ where
                 // start or the end of a rule.
                 if let Token::Begin(rule) = token {
                     self.stack.push(rule)
-                } else if let Token::End(rule) = token {
-                    if let Some(top) = self.stack.pop() {
+                } else if let Token::End(rule) = token
+                    && let Some(top) = self.stack.pop() {
                         assert_eq!(top, rule);
                     }
-                }
                 self.output.push_back(token);
             } else {
                 break;

lib/build.rs

@@ -179,12 +179,11 @@ fn generate_proto_code() {
             proto_compiler.include(path);
             proto_parser.include(path);
         }
-        if let Some(extension) = path.extension() {
-            if extension == "proto" {
+        if let Some(extension) = path.extension()
+            && extension == "proto" {
                 proto_compiler.input(path);
                 proto_parser.input(path);
             }
-        }
     }
 
     // The environment variable `YRX_EXTRA_PROTOS` allows passing a list of

lib/src/compiler/emit.rs

@@ -398,11 +398,10 @@ fn emit_expr(
                             // field in the lookup list doesn't belong to the
                             // root structure, we know that the stack already
                             // contains the object.
-                            if let Some((_, true)) = ctx.lookup_list.first() {
-                                if func.is_method() {
+                            if let Some((_, true)) = ctx.lookup_list.first()
+                                && func.is_method() {
                                     emit_lookup_object(ctx, instr);
                                 }
-                            }
                             ctx.lookup_list.clear();
                         }
                         TypeValue::Regexp(_) => {
@@ -955,12 +954,11 @@ fn emit_field_access(
     // will be emitted, encompassing all the lookups in a single call to
     // Rust code.
     for operand in field_access.operands.iter().dropping_back(1) {
-        if let Expr::Symbol(symbol) = ir.get(*operand) {
-            if let Symbol::Field { index, is_root, .. } = symbol.as_ref() {
+        if let Expr::Symbol(symbol) = ir.get(*operand)
+            && let Symbol::Field { index, is_root, .. } = symbol.as_ref() {
                 ctx.lookup_list.push((*index as i32, *is_root));
                 continue;
             }
-        }
         emit_expr(ctx, ir, *operand, instr);
     }