clippy: Fixed clippy suggestions

Author: ERoydev

src/bus.rs

@@ -11,11 +11,12 @@ pub trait BusDevice: std::fmt::Debug {
     fn as_bytes(&self) -> &Vec<u8>;
 
     fn read2(&self, addr: VmAddr) -> Option<u16> {
-        if let Some(x0) = self.read(addr) {
-            if let Some(x1) = self.read(addr + 1) {
-                return Some((x0 as u16) | ((x1 as u16) << 8));
-            }
+        if let Some(x0) = self.read(addr)
+            && let Some(x1) = self.read(addr + 1)
+        {
+            return Some((x0 as u16) | ((x1 as u16) << 8));
         };
+
         None
     }
     fn write2(&mut self, addr: VmAddr, value: u16) -> Result<()> {
@@ -39,9 +40,7 @@ pub trait BusDevice: std::fmt::Debug {
         // So from and to are addresses, each address points to one byte in the memory -> [u8; 5000]
         // TODO: Maybe its better to pass whole Register object and access the value on that memory address by getter, instead of passing register address like that
         if let Some(bytes) = self.read2(from_addr) {
-            if let Err(err) = self.write2(to_addr, bytes) {
-                return Err(err);
-            }
+            self.write2(to_addr, bytes)?
         } else {
             return Err(VMError::CopyInstructionFail);
         }

src/lib.rs

@@ -21,7 +21,7 @@ pub fn start_vm() {
 
     // Public inputs, used for the zk logic
     let mut public_inputs = ZkContext::new();
-    if let Err(_) = public_inputs.set_public_program(program.clone()) {
+    if public_inputs.set_public_program(program.clone()).is_err() {
         eprintln!("Error settings public inputs for program");
     }
 
@@ -58,7 +58,10 @@ pub fn start_vm() {
     }
 
     // Capture the OUTPUT state of the VM
-    if let Err(_) = public_inputs.set_public_output(&vm.registers, &vm.memory) {
+    if public_inputs
+        .set_public_output(&vm.registers, &*vm.memory)
+        .is_err()
+    {
         eprintln!("Cannot capture the output state from the VM.");
     }
 

src/register.rs

@@ -48,7 +48,7 @@ impl Register {
     pub fn new(register_type: RegisterId, value: VMWord) -> Self {
         Self {
             id: register_type,
-            value: value,
+            value,
         }
     }
 
@@ -65,8 +65,8 @@ pub struct RegisterBank {
     pub register_map: BTreeMap<u8, Register>, // TODO: Storing registers like that is not the most efficient way, but i am going to leave it for now, to experiment with zk first.
 }
 
-impl RegisterBank {
-    pub fn new() -> Self {
+impl Default for RegisterBank {
+    fn default() -> Self {
         let reg_hashmap: BTreeMap<u8, Register> = [
             (
                 RegisterId::RR0.id(),
@@ -125,6 +125,13 @@ impl RegisterBank {
             register_map: reg_hashmap,
         }
     }
+}
+
+impl RegisterBank {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
     pub fn get_register_read_only(&self, name: u8) -> Result<Register> {
         if let Some(reg) = self.register_map.get(&name).copied() {
             Ok(reg)

src/utils.rs

@@ -10,8 +10,7 @@ pub fn instruction_builder(opcode: u8, dest: u8, source: u8, immediate: u8) -> u
     //       |  |  |  |  |  |  | | | | | | | | | |
     //       -------------------------------------
     //       Most significant           Least significant
-    let instruction = (opcode << 12) | (dest << 8) | (source << 4) | immediate;
-    instruction
+    (opcode << 12) | (dest << 8) | (source << 4) | immediate
 }
 
 pub fn build_simple_program() -> Vec<u16> {
@@ -29,14 +28,13 @@ pub fn build_simple_program() -> Vec<u16> {
     // Store the result from r0 into memory
     let store_out = instruction_builder(0x06, 0x00, 0x00, 0x00);
 
-    let program = vec![
+    // Program
+    vec![
         load_imm_ix_rim,
         copy_ix_r0,
         load_imm_ix_rim2,
         copy_ix_r1,
         add_ix,
         store_out,
-    ];
-
-    program
+    ]
 }

src/vm.rs

@@ -75,8 +75,8 @@ pub struct VM {
     pub zk_output_enabled: bool,
 }
 
-impl VM {
-    pub fn new() -> Self {
+impl Default for VM {
+    fn default() -> Self {
         Self {
             registers: RegisterBank::new(),
             memory: Box::new(LinearMemory::new(0)),
@@ -86,6 +86,12 @@ impl VM {
             zk_output_enabled: false,
         }
     }
+}
+
+impl VM {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     pub fn set_memory(&mut self, memory: Box<dyn BusDevice>) {
         self.memory = memory;
@@ -173,15 +179,14 @@ impl VM {
 
     // If reg is RIM it will load the immediate value into that register immediately
     fn resolve_register_or_immediate(&mut self, reg_i: u8, imm_value: u16) -> Result<Register> {
-        let reg;
-        if reg_i == RegisterId::RIM.id() && imm_value != 0 {
+        let reg = if reg_i == RegisterId::RIM.id() && imm_value != 0 {
             let tmp = self.registers.get_register_mut(reg_i)?;
             tmp.value = imm_value;
-            reg = *tmp
+            *tmp
         } else {
             // When i deref a mut ref i return a copy of the Register, not a ref to the original
-            reg = *self.registers.get_register_mut(reg_i)?;
-        }
+            *self.registers.get_register_mut(reg_i)?
+        };
         Ok(reg)
     }
 
@@ -283,7 +288,11 @@ impl VMOperations for VM {
 
     fn write(&mut self, source_reg: Register, destination_reg: Register) {
         // dst_reg is address
-        if let Err(_) = self.memory.write2(destination_reg.value, source_reg.value) {
+        if self
+            .memory
+            .write2(destination_reg.value, source_reg.value)
+            .is_err()
+        {
             self.halted = true;
         }
     }
@@ -366,7 +375,7 @@ So i decide how much bit/byte to give for my opcode when i decide how much uniqu
 
 /// It depends on the OPCODE, sometimes reg.value is a bytes holding data already taken from memory, at other opcodes reg.value is an address pointing to a location in memory
 #[derive(Debug, Copy, Clone)]
-#[allow(non_camel_case_types)]
+#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
 enum Opcode {
     // These are so called mnemonics, human-readable representations of machine instructions, used to make VM ISA easier to understand
     HALT,

src/zk.rs

@@ -23,15 +23,21 @@ pub struct ZkContext {
     pub private_output_sha254: Fr,
 }
 
-impl ZkContext {
-    pub fn new() -> Self {
+impl Default for ZkContext {
+    fn default() -> Self {
         Self {
             public_program_hash: Fr::ZERO,
             public_output_hash: Fr::ZERO,
             private_program_sha254: Fr::ZERO,
             private_output_sha254: Fr::ZERO,
         }
     }
+}
+
+impl ZkContext {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     pub fn set_public_program(&mut self, program: Vec<VMWord>) -> Result<()> {
         let serialized_program = serialize(&program).unwrap();
@@ -53,7 +59,7 @@ impl ZkContext {
     pub fn set_public_output(
         &mut self,
         registers: &RegisterBank,
-        memory: &Box<dyn BusDevice>,
+        memory: &dyn BusDevice,
     ) -> Result<()> {
         // Serialize registers and memory
         let pc = registers
@@ -98,8 +104,7 @@ impl Sha256Hash {
 
         let hashed_value = hasher.finalize();
         let hashed_big_num = BigUint::from_bytes_be(&hashed_value);
-        let sha_to_field = Sha256Hash::__sha256_to_field(&hashed_big_num);
-        sha_to_field
+        Sha256Hash::__sha256_to_field(&hashed_big_num)
     }
 
     /// Hashes multiple byte slices using SHA256, concatenates them, reduces the result modulo the BN254 field,
@@ -112,8 +117,7 @@ impl Sha256Hash {
         }
         let hashed_value = hasher.finalize();
         let hashed_big_num = BigUint::from_bytes_be(&hashed_value);
-        let sha_to_field = Sha256Hash::__sha256_to_field(&hashed_big_num);
-        sha_to_field
+        Sha256Hash::__sha256_to_field(&hashed_big_num)
     }
 
     fn __sha256_to_field(sha256: &BigUint) -> Fr {
@@ -126,7 +130,6 @@ impl Sha256Hash {
         let reduced_sha = sha256 % modulus;
 
         let bytes = reduced_sha.to_bytes_be();
-        let field = Fr::from_be_bytes_mod_order(&bytes);
-        field
+        Fr::from_be_bytes_mod_order(&bytes)
     }
 }