style: apply cargo fmt again after fixing clippy warnings.

Author: plusvic

cli/src/commands/mod.rs

@@ -355,13 +355,14 @@ impl Component for CompileState {
         let mut lines = Lines::new();
 
         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(),
-                ))?]));
-            }
+            && 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

@@ -758,9 +758,9 @@ mod output_handler {
                     && !matching_rule
                         .tags()
                         .any(|tag| tag.identifier() == only_tag)
-                    {
-                        continue;
-                    }
+                {
+                    continue;
+                }
 
                 result = true;
 

cli/src/walk.rs

@@ -156,9 +156,10 @@ impl<'a> Walker<'a> {
         } else {
             if metadata.is_file() {
                 if self.pass_metadata_filter(metadata)
-                    && let Err(err) = f(self.path) {
-                        return e(err);
-                    };
+                    && let Err(err) = f(self.path)
+                {
+                    return e(err);
+                };
                 return Ok(());
             }
             self.walk_dir(f, e)
@@ -185,9 +186,10 @@ impl<'a> Walker<'a> {
                 },
             };
             if self.pass_metadata_filter(metadata)
-                && let Err(err) = f(&path) {
-                    e(err)?
-                }
+                && let Err(err) = f(&path)
+            {
+                e(err)?
+            }
         }
 
         Ok(())
@@ -245,9 +247,10 @@ impl<'a> Walker<'a> {
             match entry.metadata() {
                 Ok(metadata) => {
                     if self.pass_metadata_filter(metadata)
-                        && let Err(err) = f(entry.path()) {
-                            e(err)?
-                        }
+                        && let Err(err) = f(entry.path())
+                    {
+                        e(err)?
+                    }
                 }
                 Err(err) => e(err.into())?,
             }
@@ -453,10 +456,11 @@ impl<'a> ParWalker<'a> {
                             &mut per_thread_obj,
                         );
                         if let Err(err) = res
-                            && error(err, &msg_send).is_err() {
-                                let _ = msg_send.send(Message::Abort);
-                                break;
-                            }
+                            && error(err, &msg_send).is_err()
+                        {
+                            let _ = msg_send.send(Message::Abort);
+                            break;
+                        }
                     }
                     finalize(&per_thread_obj, &msg_send);
                 }));
@@ -487,9 +491,10 @@ impl<'a> ParWalker<'a> {
                 );
 
                 if let Err(err) = res
-                    && error(err, &msg_send).is_err() {
-                        let _ = msg_send.send(Message::Abort);
-                    }
+                    && error(err, &msg_send).is_err()
+                {
+                    let _ = msg_send.send(Message::Abort);
+                }
             }));
 
             let mut console = if cfg!(feature = "logging") {
@@ -590,10 +595,11 @@ fn output_messages<S>(
         }
 
         if let Some(console) = console.as_mut()
-            && Instant::elapsed(&last_render) > render_period {
-                console.render(state.as_ref()).unwrap();
-                last_render = Instant::now();
-            }
+            && Instant::elapsed(&last_render) > render_period
+        {
+            console.render(state.as_ref()).unwrap();
+            last_render = Instant::now();
+        }
     }
 }
 

fmt/src/lib.rs

@@ -918,7 +918,6 @@ impl Formatter {
             };
 
         let tokens = AddIndentation::new(tokens, self.indentation);
-        
 
         RemoveTrailingSpaces::new(tokens)
     }

fmt/src/processor/mod.rs

@@ -412,9 +412,10 @@ where
                 if let Token::Begin(rule) = token {
                     self.stack.push(rule)
                 } else if let Token::End(rule) = token
-                    && let Some(top) = self.stack.pop() {
-                        assert_eq!(top, rule);
-                    }
+                    && let Some(top) = self.stack.pop()
+                {
+                    assert_eq!(top, rule);
+                }
                 self.output.push_back(token);
             } else {
                 break;

lib/build.rs

@@ -180,10 +180,11 @@ fn generate_proto_code() {
             proto_parser.include(path);
         }
         if let Some(extension) = path.extension()
-            && extension == "proto" {
-                proto_compiler.input(path);
-                proto_parser.input(path);
-            }
+            && 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

@@ -399,9 +399,10 @@ fn emit_expr(
                             // root structure, we know that the stack already
                             // contains the object.
                             if let Some((_, true)) = ctx.lookup_list.first()
-                                && func.is_method() {
-                                    emit_lookup_object(ctx, instr);
-                                }
+                                && func.is_method()
+                            {
+                                emit_lookup_object(ctx, instr);
+                            }
                             ctx.lookup_list.clear();
                         }
                         TypeValue::Regexp(_) => {
@@ -955,10 +956,11 @@ fn emit_field_access(
     // Rust code.
     for operand in field_access.operands.iter().dropping_back(1) {
         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;
-            }
+            && 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);
     }