clippy

analysis/src/ir/custom.rs

@@ -1,22 +1,22 @@
 pub mod help {
     use crate::ir::{ConstValue, Operand, Register};
 
-    pub trait AsOperand {
-        fn as_operand(self) -> Operand;
+    pub trait ToOperand {
+        fn to_operand(self) -> Operand;
     }
 
-    pub fn op(o: impl AsOperand) -> Operand {
-        o.as_operand()
+    pub fn op(o: impl ToOperand) -> Operand {
+        o.to_operand()
     }
 
-    impl AsOperand for Register {
-        fn as_operand(self) -> Operand {
+    impl ToOperand for Register {
+        fn to_operand(self) -> Operand {
             Operand::Reg(self)
         }
     }
 
-    impl AsOperand for u64 {
-        fn as_operand(self) -> Operand {
+    impl ToOperand for u64 {
+        fn to_operand(self) -> Operand {
             Operand::Const(ConstValue::u64(self))
         }
     }

analysis/src/ir/info.rs

@@ -3,7 +3,7 @@ use rustc_hash::FxHashSet;
 use super::{BbIdx, Branch, Func, Location, Operand};
 use crate::ir::visit::Visitor;
 
-pub fn traverse_postorder<'a>(func: &'a Func<'_>) -> Vec<BbIdx> {
+pub fn traverse_postorder(func: &Func<'_>) -> Vec<BbIdx> {
     // the final traversial, backwards.
     // the starting bb has to be visited last.
     let mut traversal = vec![BbIdx(0)];

analysis/src/lower.rs

@@ -42,7 +42,7 @@ pub fn lower_translation_unit<'cx>(
                 };
 
                 let def_id = lcx.next_def_id();
-                let func = lower_func(&lcx, body, def_span, ident.0, ret_ty, params)?;
+                let func = lower_func(lcx, body, def_span, ident.0, ret_ty, params)?;
 
                 let args = &*lcx
                     .arena
@@ -450,7 +450,7 @@ fn lower_func<'cx>(
             def_span,
             ret_ty,
             lcx,
-            params.len().try_into().unwrap(),
+            params.len(),
         ),
         lcx,
     };

analysis/src/lower/builder.rs

@@ -105,7 +105,7 @@ impl<'a, 'cx> FuncBuilder<'a, 'cx> {
     }
 
     pub fn load(&mut self, tyl: TyLayout<'cx>, ptr: Operand, span: Span) -> Register {
-        let reg = self.new_reg(None, tyl.clone());
+        let reg = self.new_reg(None, tyl);
         let stmt = StatementKind::Load {
             result: reg,
             ptr,

analysis/src/lower/typeck.rs

@@ -1,3 +1,5 @@
+use std::cmp::Ordering;
+
 use parser::{
     ast::{IntSign, IntTy, IntTyKind},
     Error, Span,
@@ -61,15 +63,18 @@ impl<'a, 'cx> FnLoweringCtxt<'a, 'cx> {
                 } else if (lhs_sign.unsigned() && rhs_prom_int.0.unsigned())
                     || (lhs_sign.signed() && rhs_sign.signed())
                 {
-                    if lhs_kind > rhs_kind {
-                        rhs_coerce.extend(self.coerce(rhs_prom, lhs_prom)?);
-                        lhs
-                    } else if lhs_kind < rhs_kind {
-                        lhs_coerce.extend(self.coerce(lhs_prom, rhs_prom)?);
-                        rhs
-                    } else {
-                        unreachable!("integers must have different rank here")
+                    match lhs_kind.cmp(&rhs_kind) {
+                        Ordering::Greater => {
+                            rhs_coerce.extend(self.coerce(rhs_prom, lhs_prom)?);
+                            lhs
+                        }
+                        Ordering::Less => {
+                            lhs_coerce.extend(self.coerce(lhs_prom, rhs_prom)?);
+                            rhs
+                        }
+                        Ordering::Equal => unreachable!("integers must have different rank here"),
                     }
+
                 // Otherwise, if the operand that has unsigned integer type has rank greater or
                 // equal to the rank of the type of the other operand, then the operand with
                 // signed integer type is converted to the type of the operand with unsigned