Fix all clippy warnings (#564)

* Fix all clippy warnings

* Revert usage of inclusive ranges

* Remove redundant function argument

* Revert use of unavailable pointer methods

* Introduce ContiguousCaseRange

lib/codegen/src/ir/dfg.rs

@@ -127,7 +127,7 @@ fn maybe_resolve_aliases(values: &PrimaryMap<Value, ValueData>, value: Value) ->
     let mut v = value;
 
     // Note that values may be empty here.
-    for _ in 0..1 + values.len() {
+    for _ in 0..values.len() + 1 {
         if let ValueData::Alias { original, .. } = values[v] {
             v = original;
         } else {
@@ -174,8 +174,7 @@ impl<'a> Iterator for Values<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         self.inner
             .by_ref()
-            .filter(|kv| valid_valuedata(kv.1))
-            .next()
+            .find(|kv| valid_valuedata(kv.1))
             .map(|kv| kv.0)
     }
 }

lib/codegen/src/ir/function.rs

@@ -178,19 +178,14 @@ impl Function {
     ///
     /// This function can only be used after the code layout has been computed by the
     /// `binemit::relax_branches()` function.
-    pub fn inst_offsets<'a>(
-        &'a self,
-        func: &'a Function,
-        ebb: Ebb,
-        encinfo: &EncInfo,
-    ) -> InstOffsetIter<'a> {
+    pub fn inst_offsets<'a>(&'a self, ebb: Ebb, encinfo: &EncInfo) -> InstOffsetIter<'a> {
         assert!(
             !self.offsets.is_empty(),
             "Code layout must be computed first"
         );
         InstOffsetIter {
             encinfo: encinfo.clone(),
-            func,
+            func: self,
             divert: RegDiversions::new(),
             encodings: &self.encodings,
             offset: self.offsets[ebb],

lib/codegen/src/isa/encoding.rs

@@ -85,7 +85,7 @@ type SizeCalculatorFn = fn(&RecipeSizing, Inst, &RegDiversions, &Function) -> u8
 /// Returns the base size of the Recipe, assuming it's fixed. This is the default for most
 /// encodings; others can be variable and longer than this base size, depending on the registers
 /// they're using and use a different function, specific per platform.
-pub fn base_size(sizing: &RecipeSizing, _: Inst, _2: &RegDiversions, _3: &Function) -> u8 {
+pub fn base_size(sizing: &RecipeSizing, _: Inst, _: &RegDiversions, _: &Function) -> u8 {
     sizing.base_size
 }
 

lib/codegen/src/print_errors.rs

@@ -25,7 +25,7 @@ pub fn pretty_verifier_error<'a>(
     let mut w = String::new();
 
     decorate_function(
-        &mut PrettyVerifierError(func_w.unwrap_or(Box::new(PlainWriter)), &mut errors),
+        &mut PrettyVerifierError(func_w.unwrap_or_else(|| Box::new(PlainWriter)), &mut errors),
         &mut w,
         func,
         isa,

lib/codegen/src/verifier/mod.rs

@@ -234,7 +234,8 @@ pub fn verify_function<'a, FOI: Into<FlagsOrIsa<'a>>>(
     let verifier = Verifier::new(func, fisa.into());
     let result = verifier.run(&mut errors);
     if errors.is_empty() {
-        Ok(result.unwrap())
+        result.unwrap();
+        Ok(())
     } else {
         Err(errors)
     }
@@ -392,30 +393,22 @@ impl<'a> Verifier<'a> {
                     );
                 }
 
-                match heap_data.style {
-                    ir::HeapStyle::Dynamic { bound_gv, .. } => {
-                        if !self.func.global_values.is_valid(bound_gv) {
-                            return nonfatal!(
-                                errors,
-                                heap,
-                                "invalid bound global value {}",
-                                bound_gv
-                            );
-                        }
-
-                        let index_type = heap_data.index_type;
-                        let bound_type = self.func.global_values[bound_gv].global_type(isa);
-                        if index_type != bound_type {
-                            report!(
-                                errors,
-                                heap,
-                                "heap index type {} differs from the type of its bound, {}",
-                                index_type,
-                                bound_type
-                            );
-                        }
+                if let ir::HeapStyle::Dynamic { bound_gv, .. } = heap_data.style {
+                    if !self.func.global_values.is_valid(bound_gv) {
+                        return nonfatal!(errors, heap, "invalid bound global value {}", bound_gv);
+                    }
+
+                    let index_type = heap_data.index_type;
+                    let bound_type = self.func.global_values[bound_gv].global_type(isa);
+                    if index_type != bound_type {
+                        report!(
+                            errors,
+                            heap,
+                            "heap index type {} differs from the type of its bound, {}",
+                            index_type,
+                            bound_type
+                        );
                     }
-                    _ => {}
                 }
             }
         }