clippy fixes

Author: ekiwi

patronus-egraphs/src/rewrites.rs

@@ -236,8 +236,8 @@ pub struct ArithMatch {
 fn check_width_consistency(pattern: &Pattern<Arith>) {
     let exprs = pattern.ast.as_ref();
     for e_node_or_var in exprs.iter() {
-        if let ENodeOrVar::ENode(expr) = e_node_or_var {
-            if is_bin_op(expr) {
+        if let ENodeOrVar::ENode(expr) = e_node_or_var
+            && is_bin_op(expr) {
                 // w, w_a, s_a, a, w_b, s_b, b
                 let a_width_id = usize::from(expr.children()[1]);
                 let a_id = usize::from(expr.children()[3]);
@@ -258,7 +258,6 @@ fn check_width_consistency(pattern: &Pattern<Arith>) {
                     );
                 }
             }
-        }
     }
 }
 

patronus/src/btor2/parse.rs

@@ -111,11 +111,10 @@ impl<'a> Parser<'a> {
 
         // get a better name if none could be determined from the file content
         // this better name is often derived from the filename or other meta info
-        if self.sys.name.is_empty() {
-            if let Some(name) = backup_name {
+        if self.sys.name.is_empty()
+            && let Some(name) = backup_name {
                 self.sys.name = name.to_string();
             }
-        }
 
         // possibly improve state names through yosys aliases which look like:
         // better_name = zext(__state__, 0)

patronus/src/expr/parse.rs

@@ -228,12 +228,11 @@ impl<'a> Parser<'a> {
     }
 
     fn try_parse_width_int(&mut self) -> Option<WidthInt> {
-        if let Some(m) = DEC_NUM_REGEX.find(self.inp) {
-            if let Ok(num) = m.as_str().parse() {
+        if let Some(m) = DEC_NUM_REGEX.find(self.inp)
+            && let Ok(num) = m.as_str().parse() {
                 self.consume_m(&m);
                 return Some(num);
             }
-        }
         None
     }
 

patronus/src/smt/serialize.rs

@@ -198,12 +198,11 @@ pub fn serialize_expr(out: &mut impl Write, ctx: &Context, expr: ExprRef) -> Res
             // we had to serialize some children first => we need a closing parenthesis
             if pc > 0 {
                 // special continuation for zero extend of booleans (for which we use an ite)
-                if let Expr::BVZeroExt { e, by, .. } = expr {
-                    if e.get_type(ctx).is_bool() {
+                if let Expr::BVZeroExt { e, by, .. } = expr
+                    && e.get_type(ctx).is_bool() {
                         let zeros = "0".repeat(*by as usize);
                         write!(out, " #b{}1 #b{}0", zeros, zeros)?;
                     }
-                }
                 // everyone gets a closing parenthesis
                 write!(out, ")")?;
             }

patronus/src/system/analysis.rs

@@ -28,15 +28,14 @@ fn internal_count_expr_uses(
     while let Some(expr) = todo.pop() {
         if let Some(state) = states.get(&expr) {
             // for states, we also want to mark the initial and the next expression as used
-            if let Some(init) = state.init {
-                if !ignore_init {
+            if let Some(init) = state.init
+                && !ignore_init {
                     let count = use_count[init];
                     if count == 0 {
                         use_count[init] = 1;
                         todo.push(init);
                     }
                 }
-            }
             if let Some(next) = state.next {
                 let count = use_count[next];
                 if count == 0 {
@@ -105,20 +104,16 @@ fn cone_of_influence_impl(
 
         // for states, we might want to follow the next and init expressions
         if let Some(state) = states.get(&expr_ref) {
-            if follow_init {
-                if let Some(c) = state.init {
-                    if !visited.contains(&c) {
+            if follow_init
+                && let Some(c) = state.init
+                    && !visited.contains(&c) {
                         todo.push(c);
                     }
-                }
-            }
-            if follow_next {
-                if let Some(c) = state.next {
-                    if !visited.contains(&c) {
+            if follow_next
+                && let Some(c) = state.next
+                    && !visited.contains(&c) {
                         todo.push(c);
                     }
-                }
-            }
         }
 
         // check to see if this is a state or input

patronus/src/system/transition_system.rs

@@ -65,14 +65,12 @@ impl TransitionSystem {
     }
 
     pub fn update_signal_name(&mut self, old: ExprRef, new: ExprRef) {
-        if old != new {
-            if let Some(old_name) = self.names[old] {
-                if self.names[new].is_none() {
+        if old != new
+            && let Some(old_name) = self.names[old]
+                && self.names[new].is_none() {
                     self.names[new] = Some(old_name);
                     self.names[old] = None;
                 }
-            }
-        }
     }
 
     pub fn add_input(&mut self, ctx: &Context, symbol: ExprRef) {
@@ -143,11 +141,10 @@ impl TransitionSystem {
         // update names
         let old_name_exprs = self.names.non_default_value_keys().collect::<Vec<_>>();
         for old_expr in old_name_exprs.into_iter() {
-            if let Some(new_expr) = update(old_expr) {
-                if new_expr != old_expr {
+            if let Some(new_expr) = update(old_expr)
+                && new_expr != old_expr {
                     self.names[new_expr] = self.names[old_expr];
                 }
-            }
         }
     }
 

python/src/smt.rs

@@ -6,12 +6,12 @@ use crate::ExprRef;
 use crate::ctx::{ContextGuardRead, ContextGuardWrite};
 use baa::{BitVecOps, Value};
 use num_bigint::BigInt;
-use patronus::expr::{Context, TypeCheck};
+use patronus::expr::TypeCheck;
 use patronus::mc::get_smt_value;
 use patronus::smt::*;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 
 #[pyclass]
 pub struct SolverCtx {

tools/simplify/src/main.rs

@@ -4,9 +4,9 @@
 
 use clap::Parser;
 use patronus::expr::*;
-use patronus::smt::{SmtCommand, parse_command, read_command, serialize_cmd};
+use patronus::smt::{SmtCommand, read_command, serialize_cmd};
 use rustc_hash::FxHashMap;
-use std::io::{BufRead, BufReader, BufWriter};
+use std::io::{BufReader, BufWriter};
 use std::path::PathBuf;
 
 #[derive(Parser, Debug)]