chore: fix clippy

Author: andreiltd

src/constant_offsets.rs

@@ -250,9 +250,9 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) {
 
         for (_, param) in &block_def.params {
             // Insert the common-base computations where needed.
-            if let Some(common_base_const) = offset_base_const.get(&param) {
+            if let Some(common_base_const) = offset_base_const.get(param) {
                 new_insts.push(*common_base_const);
-                new_insts.push(*offset_base.get(&param).unwrap());
+                new_insts.push(*offset_base.get(param).unwrap());
             }
         }
 
@@ -271,8 +271,8 @@ pub fn run(func: &mut FunctionBody, cfg: &CFGInfo) {
                         // Update the offset embedded in the Operator
                         // and use the `base` value instead as the
                         // address arg.
-                        let mut op = op.clone();
-                        let mut args = args.iter().cloned().collect::<Vec<_>>();
+                        let mut op = *op;
+                        let mut args = args.to_vec();
                         let common_base = *offset_base.get(&base).unwrap();
                         let offset = *min_offset_from.get(&base).unwrap();
                         assert!(offset <= 0);

src/dce.rs

@@ -20,7 +20,7 @@ fn op_can_be_removed(op: &Operator) -> bool {
         // If the *only* side-effect is a possible trap, we can remove
         // the op if otherwise unused, because we're assuming the
         // program doesn't trap.
-        op if op.effects() == &[SideEffect::Trap] => true,
+        op if op.effects() == [SideEffect::Trap] => true,
         // `table.size` and `memory.size` technically access state
         // tracked via side-effects, but can otherwise be removed if
         // unused. Likewise for table element and global accesses.

src/escape.rs

@@ -70,7 +70,7 @@ fn shadow_stack_escapes(func: &FunctionBody, cfg: &CFGInfo) -> EscapeAnalysisRes
                     return EscapeAnalysisResult::Escapes;
                 }
             }
-            &Terminator::Return { ref values } => {
+            Terminator::Return { values } => {
                 if values.iter().any(|v| tainted.contains(v)) {
                     log::trace!("taint on return value causes escape");
                     return EscapeAnalysisResult::Escapes;
@@ -110,7 +110,7 @@ fn shadow_stack_escapes(func: &FunctionBody, cfg: &CFGInfo) -> EscapeAnalysisRes
 }
 
 pub(crate) fn remove_shadow_stack_if_non_escaping(func: &mut FunctionBody, cfg: &CFGInfo) {
-    if let EscapeAnalysisResult::NonEscaping(values_to_remove) = shadow_stack_escapes(func, &cfg) {
+    if let EscapeAnalysisResult::NonEscaping(values_to_remove) = shadow_stack_escapes(func, cfg) {
         log::trace!("removing shadow stack operations: {:?}", values_to_remove);
         let ty_u32 = func.type_pool.single(Type::I32);
         let const_zero = func.values.push(ValueDef::Operator(

src/eval.rs

@@ -122,12 +122,12 @@ pub(crate) fn partially_evaluate<'a>(
     // Expand function bodies of any function named in a directive.
     let mut funcs = HashMap::default();
     for directive in &directives {
-        if !funcs.contains_key(&directive.func) {
+        if let std::collections::hash_map::Entry::Vacant(e) = funcs.entry(directive.func) {
             let mut f = module.clone_and_expand_body(directive.func)?;
 
             if let Some(path) = &output_ir {
                 let mut generic_ir_file = path.clone();
-                generic_ir_file.push(&format!("generic_{}.txt", directive.func));
+                generic_ir_file.push(format!("generic_{}.txt", directive.func));
                 std::fs::write(
                     &generic_ir_file,
                     format!("{}", f.display_verbose("", Some(&module))),
@@ -150,7 +150,7 @@ pub(crate) fn partially_evaluate<'a>(
 
             f.convert_to_max_ssa(Some(cut_blocks));
 
-            funcs.insert(directive.func, (f, cfg, stats));
+            e.insert((f, cfg, stats));
         }
     }
 
@@ -196,7 +196,7 @@ pub(crate) fn partially_evaluate<'a>(
                             live.sort();
                             writeln!(&mut s, "# {}: {:?}", block, live).unwrap();
                         }
-                        writeln!(&mut s, "").unwrap();
+                        writeln!(&mut s).unwrap();
                         writeln!(&mut s, "{}", body.display_verbose("", Some(&module))).unwrap();
                         s
                     } else {
@@ -259,7 +259,7 @@ pub(crate) fn partially_evaluate<'a>(
 
         if let Some(path) = &output_ir {
             let mut specialized_ir_file = path.clone();
-            specialized_ir_file.push(&format!("specialized_{}_to_{}.txt", directive.func, func));
+            specialized_ir_file.push(format!("specialized_{}_to_{}.txt", directive.func, func));
             std::fs::write(&specialized_ir_file, ir).unwrap();
         }
 
@@ -483,10 +483,8 @@ fn find_cut_blocks(
             let changed = new != current;
             highest_same_ctx_ancestor[succ] = new;
             log::trace!("highest same-context ancestor for {}: {}", succ, new);
-            if changed {
-                if queue_set.insert(succ) {
-                    queue.push(succ);
-                }
+            if changed && queue_set.insert(succ) {
+                queue.push(succ);
             }
         });
     }
@@ -569,10 +567,7 @@ enum EvalResult {
 }
 impl EvalResult {
     fn is_handled(&self) -> bool {
-        match self {
-            &EvalResult::Unhandled => false,
-            _ => true,
-        }
+        !matches!(self, &EvalResult::Unhandled)
     }
 }
 
@@ -1106,7 +1101,7 @@ impl<'a> Evaluator<'a> {
                 ref if_true,
                 ref if_false,
             } => {
-                assert!(!state.pending_specialize.is_some());
+                assert!(state.pending_specialize.is_none());
                 let (cond, abs_cond) = self.use_value(state.context, orig_block, new_block, cond);
                 // Update pending context with new stack if necessary.
                 match abs_cond.as_const_truthy() {
@@ -1147,7 +1142,7 @@ impl<'a> Evaluator<'a> {
                     },
                 }
             }
-            &Terminator::Br { ref target } => {
+            Terminator::Br { target } => {
                 if let Some((index, lo, hi)) = state.pending_specialize.take() {
                     log::trace!(
                         "Branch to target {} with PendingSpecialize on {}",
@@ -1192,7 +1187,7 @@ impl<'a> Evaluator<'a> {
                 ref targets,
                 ref default,
             } => {
-                assert!(!state.pending_specialize.is_some());
+                assert!(state.pending_specialize.is_none());
                 let (value, abs_value) =
                     self.use_value(state.context, orig_block, new_block, value);
                 if let Some(selector) = abs_value.as_const_u32() {
@@ -1238,7 +1233,7 @@ impl<'a> Evaluator<'a> {
                     }
                 }
             }
-            &Terminator::Return { ref values } => {
+            Terminator::Return { values } => {
                 let values = values
                     .iter()
                     .map(|&value| {
@@ -1255,6 +1250,7 @@ impl<'a> Evaluator<'a> {
         self.func.blocks[new_block].terminator = new_term;
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn abstract_eval(
         &mut self,
         orig_block: Block,
@@ -1319,6 +1315,7 @@ impl<'a> Evaluator<'a> {
         Ok(EvalResult::Normal(ret))
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn abstract_eval_intrinsic(
         &mut self,
         orig_block: Block,
@@ -1470,7 +1467,7 @@ impl<'a> Evaluator<'a> {
                 } else if Some(function_index) == self.intrinsics.pop_stack {
                     log::trace!("pop_stack: current stack is {:?}", state.flow.stack);
                     self.stats.virtstack_reads += 1;
-                    if state.flow.stack.len() > 0 {
+                    if !state.flow.stack.is_empty() {
                         let (_, reg) = state.flow.stack.remove(0);
                         let (value, abs) = match reg {
                             RegValue::Value { data, abs, .. } => (data, abs),
@@ -1664,6 +1661,7 @@ impl<'a> Evaluator<'a> {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn abstract_eval_regs(
         &mut self,
         _inst: Value,
@@ -2286,7 +2284,7 @@ impl<'a> Evaluator<'a> {
         //
         // Also look at `locals` and find locals present in pred and
         // not in some succ, and sync them.
-        for (_, &block) in &self.block_map {
+        for &block in self.block_map.values() {
             if self.func.blocks[block].succs.is_empty() {
                 continue;
             }

src/filter.rs

@@ -75,7 +75,7 @@ fn gen_replacement_bytecode(
         _ => {
             anyhow::ensure!(results.len() <= 1);
             anyhow::ensure!(results.len() <= args.len());
-            if args.len() > 0 && results.len() > 0 {
+            if !args.is_empty() && !results.is_empty() {
                 anyhow::ensure!(
                     args[0] == results[0],
                     "Intrinsic's first arg is different type than result"
@@ -127,12 +127,9 @@ impl Rewrite {
         // Scan globals section once to count globals so that we know
         // the indices of the new globals that we add.
         for payload in parser.clone().parse_all(module) {
-            match payload? {
-                Payload::GlobalSection(globals) => {
-                    weval_globals += globals.count();
-                    break;
-                }
-                _ => {}
+            if let Payload::GlobalSection(globals) = payload? {
+                weval_globals += globals.count();
+                break;
             }
         }
 
@@ -471,18 +468,15 @@ impl Rewrite {
                         let mut func_names = wasm_encoder::NameMap::new();
                         for subsection in name_reader {
                             let subsection = subsection?;
-                            match subsection {
-                                wasmparser::Name::Function(names) => {
-                                    for name in names {
-                                        let name = name?;
-                                        if let Some(&FuncRemap::Index(new_index)) =
-                                            self.func_remap.get(&name.index)
-                                        {
-                                            func_names.append(new_index, name.name);
-                                        }
+                            if let wasmparser::Name::Function(names) = subsection {
+                                for name in names {
+                                    let name = name?;
+                                    if let Some(&FuncRemap::Index(new_index)) =
+                                        self.func_remap.get(&name.index)
+                                    {
+                                        func_names.append(new_index, name.name);
                                     }
                                 }
-                                _ => {}
                             }
                         }
                         names.functions(&func_names);

src/image.rs

@@ -199,13 +199,12 @@ impl Image {
         let table = self
             .main_table
             .ok_or_else(|| anyhow::anyhow!("no main table"))?;
-        Ok(self
-            .tables
+        self.tables
             .get(&table)
             .unwrap()
             .get(idx as usize)
             .copied()
-            .ok_or_else(|| anyhow::anyhow!("func ptr out of bounds"))?)
+            .ok_or_else(|| anyhow::anyhow!("func ptr out of bounds"))
     }
 
     pub(crate) fn append_data(&mut self, id: Memory, data: Vec<u8>) {
@@ -216,7 +215,7 @@ impl Image {
         let padding = padded_len - data_len;
         image
             .image
-            .extend(data.into_iter().chain(std::iter::repeat(0).take(padding)));
+            .extend(data.into_iter().chain(std::iter::repeat_n(0, padding)));
         log::debug!(
             "Appending data ({} bytes, {} padding): went from {} bytes to {} bytes",
             data_len,

src/intrinsics.rs

@@ -152,17 +152,16 @@ pub(crate) fn find_global_data_by_exported_func(module: &Module, name: &str) ->
     // I32Add of a global (the GOT memory base) and an I32Const.
 
     let extract_const_value = |value| match &body.values[value] {
-        ValueDef::Operator(Operator::I32Const { value }, _, _) => Some(*value as u32),
+        ValueDef::Operator(Operator::I32Const { value }, _, _) => Some(*value),
         ValueDef::Operator(Operator::I32Add, args, _) => {
             let args = &body.arg_pool[*args];
             match (&body.values[args[0]], &body.values[args[1]]) {
                 (
                     ValueDef::Operator(Operator::GlobalGet { global_index }, _, _),
                     ValueDef::Operator(Operator::I32Const { value }, _, _),
-                ) => match module.globals[*global_index].value {
-                    Some(global_value) => Some((global_value as u32) + *value),
-                    _ => None,
-                },
+                ) => module.globals[*global_index]
+                    .value
+                    .map(|global_value| (global_value as u32) + *value),
                 _ => None,
             }
         }

src/liveness.rs

@@ -98,10 +98,8 @@ impl<'a> Liveness<'a> {
                         changed = true;
                     }
                 }
-                if changed {
-                    if workqueue_set.insert(pred) {
-                        workqueue.push_back(pred);
-                    }
+                if changed && workqueue_set.insert(pred) {
+                    workqueue.push_back(pred);
                 }
             }
         }

src/main.rs

@@ -20,7 +20,7 @@ mod state;
 mod stats;
 mod value;
 
-const STUBS: &'static str = include_str!("../lib/weval-stubs.wat");
+const STUBS: &str = include_str!("../lib/weval-stubs.wat");
 
 #[derive(Clone, Debug, StructOpt)]
 pub enum Command {
@@ -151,6 +151,7 @@ async fn wizen_impl(
 }
 
 /// Weval a wasm.
+#[allow(clippy::too_many_arguments)]
 pub fn weval(
     input_module: PathBuf,
     output_module: PathBuf,
@@ -173,11 +174,7 @@ pub fn weval(
     let input_hash = cache::compute_hash(&raw_bytes[..]);
 
     // Open the cache and read-only cache, if any.
-    let cache = cache::Cache::open(
-        cache.as_ref().map(|p| p.as_path()),
-        cache_ro.as_ref().map(|p| p.as_path()),
-        input_hash,
-    )?;
+    let cache = cache::Cache::open(cache.as_deref(), cache_ro.as_deref(), input_hash)?;
 
     // Optionally, Wizen the module first.
     let module_bytes = if do_wizen {
@@ -193,8 +190,7 @@ pub fn weval(
     if verbose {
         eprintln!("Parsing the module...");
     }
-    let mut frontend_opts = waffle::FrontendOptions::default();
-    frontend_opts.debug = true;
+    let frontend_opts = waffle::FrontendOptions { debug: true };
     let module = waffle::Module::from_wasm_bytes(&module_bytes[..], &frontend_opts)?;
 
     // Build module image.

src/state.rs

@@ -39,7 +39,7 @@ use crate::value::{AbstractValue, WasmVal};
 use fxhash::FxHashMap as HashMap;
 use std::collections::hash_map::Entry;
 use std::collections::{BTreeMap, BTreeSet};
-use waffle::entity::{EntityRef, EntityVec, PerEntity};
+use waffle::entity::{EntityVec, PerEntity};
 use waffle::{Block, FunctionBody, Global, Type, Value};
 
 waffle::declare_entity!(Context, "context");
@@ -64,7 +64,7 @@ pub(crate) struct Contexts {
 
 impl Contexts {
     pub(crate) fn create(&mut self, parent: Option<Context>, elem: ContextElem) -> Context {
-        let parent = parent.unwrap_or(Context::invalid());
+        let parent = parent.unwrap_or_default();
         match self.dedup.entry((parent, elem.clone())) {
             Entry::Occupied(o) => *o.get(),
             Entry::Vacant(v) => {
@@ -242,7 +242,7 @@ fn map_meet_with<
                 *val = bot.clone();
                 changed |= old != *val;
             } else {
-                to_remove.push(k.clone());
+                to_remove.push(*k);
                 changed = true;
             }
         }
@@ -421,8 +421,8 @@ impl FunctionState {
         }
 
         // Set specialization globals, if any.
-        for i in 0..num_globals {
-            self.specialization_globals.push(args[i].clone());
+        for arg in args.iter().take(num_globals) {
+            self.specialization_globals.push(arg.clone());
         }
     }
 }