memory address: add Add<usize>

Author: tcoratger

crates/leanVm/src/context/run_context.rs

@@ -42,7 +42,7 @@ impl RunContext {
         match operand {
             MemOrConstant::Constant(val) => Ok(MemoryValue::Int(*val)),
             MemOrConstant::MemoryAfterFp { shift } => {
-                let addr = self.fp.add_usize(*shift)?;
+                let addr = (self.fp + *shift)?;
                 memory
                     .get(addr)
                     .ok_or(MemoryError::UninitializedMemory(addr))
@@ -62,7 +62,7 @@ impl RunContext {
         match operand {
             MemOrFp::Fp => Ok(MemoryValue::Address(self.fp)),
             MemOrFp::MemoryAfterFp { shift } => {
-                let addr = self.fp.add_usize(*shift)?;
+                let addr = (self.fp + *shift)?;
                 memory
                     .get(addr)
                     .ok_or(MemoryError::UninitializedMemory(addr))
@@ -85,7 +85,7 @@ impl RunContext {
             MemOrFpOrConstant::Constant(val) => Ok(MemoryValue::Int(*val)),
             MemOrFpOrConstant::Fp => Ok(MemoryValue::Address(self.fp)),
             MemOrFpOrConstant::MemoryAfterFp { shift } => {
-                let addr = self.fp.add_usize(*shift)?;
+                let addr = (self.fp + *shift)?;
                 memory
                     .get(addr)
                     .ok_or_else(|| MemoryError::UninitializedMemory(addr).into())
@@ -222,7 +222,7 @@ mod tests {
     fn test_get_value_from_mem_or_fp_or_constant_is_mem_success() {
         let mut memory = MemoryManager::default();
         let fp = memory.add();
-        let addr_to_read = fp.add_usize(7).unwrap();
+        let addr_to_read = (fp + 7).unwrap();
         let expected_val = MemoryValue::Address(MemoryAddress::new(5, 5));
         memory.memory.insert(addr_to_read, expected_val).unwrap();
 

crates/leanVm/src/core.rs

@@ -64,7 +64,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
 
             if is_zero {
                 // **Condition is zero**: The jump is not taken. Advance the `pc` by one.
-                self.run_context.pc().add_usize(1)?
+                (*self.run_context.pc() + 1)?
             } else {
                 // **Condition is non-zero**: Execute the jump.
                 //
@@ -80,7 +80,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
             }
         } else {
             // For any instruction other than `JumpIfNotZero`, advance the `pc` by one.
-            self.run_context.pc().add_usize(1)?
+            (*self.run_context.pc() + 1)?
         };
 
         // Update the virtual machine's program counter with the calculated next address.
@@ -99,7 +99,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
                 MemOrFp::Fp => self.run_context.fp,
                 // The instruction specifies updating `fp` to a value from memory.
                 MemOrFp::MemoryAfterFp { shift } => {
-                    let addr = self.run_context.fp().add_usize(*shift)?;
+                    let addr = (*self.run_context.fp() + *shift)?;
                     let value = self
                         .memory_manager
                         .get(addr)
@@ -272,7 +272,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
             .value_from_mem_or_fp_or_constant(res, &self.memory_manager)?;
 
         // Calculate the address of the first-level pointer, `fp + shift_0`.
-        let ptr_shift_0_addr = self.run_context.fp.add_usize(shift_0)?;
+        let ptr_shift_0_addr = (self.run_context.fp + shift_0)?;
 
         // Read the pointer from memory. It must be a `MemoryAddress` type.
         let ptr: MemoryAddress = self
@@ -282,7 +282,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
             .try_into()?;
 
         // Calculate the final, second-level address: `ptr + shift_1`.
-        let ptr_shift_1_addr = ptr.add_usize(shift_1)?;
+        let ptr_shift_1_addr = (ptr + shift_1)?;
 
         // Branch execution based on whether `res` was a known value or an unwritten address.
         match res_lookup_result {
@@ -326,7 +326,7 @@ impl<PERM16, PERM24> VirtualMachine<PERM16, PERM24> {
         // Read Pointers from Memory
         //
         // The instruction specifies 4 consecutive pointers starting at `fp + shift`.
-        let base_ptr_addr = self.run_context.fp.add_usize(shift)?;
+        let base_ptr_addr = (self.run_context.fp + shift)?;
         let ptrs: [MemoryValue; 4] = self.memory_manager.get_array(base_ptr_addr)?;
 
         // Convert the `MemoryValue` pointers to `MemoryAddress`.
@@ -452,11 +452,7 @@ mod tests {
         let pc = MemoryAddress::new(0, 10);
         let fp = MemoryAddress::new(1, 5);
         // Pre-load memory with a zero value at the address `fp + 1`, which will be our condition.
-        let mut vm = setup_vm(
-            pc,
-            fp,
-            &[(fp.add_usize(1).unwrap(), MemoryValue::Int(F::ZERO))],
-        );
+        let mut vm = setup_vm(pc, fp, &[((fp + 1).unwrap(), MemoryValue::Int(F::ZERO))]);
         // Define a JNZ instruction where the condition points to the zero value.
         let instruction = Instruction::JumpIfNotZero {
             condition: MemOrConstant::MemoryAfterFp { shift: 1 },
@@ -482,9 +478,9 @@ mod tests {
             fp,
             &[
                 // The condition value (non-zero).
-                (fp.add_usize(1).unwrap(), MemoryValue::Int(F::from_u64(42))),
+                ((fp + 1).unwrap(), MemoryValue::Int(F::from_u64(42))),
                 // The destination address for the jump.
-                (fp.add_usize(2).unwrap(), MemoryValue::Address(jump_target)),
+                ((fp + 2).unwrap(), MemoryValue::Address(jump_target)),
             ],
         );
         // Define a JNZ instruction pointing to the condition and destination.
@@ -509,7 +505,7 @@ mod tests {
             pc,
             fp,
             &[(
-                fp.add_usize(1).unwrap(),
+                (fp + 1).unwrap(),
                 MemoryValue::Address(MemoryAddress::new(8, 8)),
             )],
         );
@@ -554,7 +550,7 @@ mod tests {
         let mut vm = setup_vm(
             MemoryAddress::new(0, 0),
             fp,
-            &[(fp.add_usize(3).unwrap(), MemoryValue::Address(new_fp))],
+            &[((fp + 3).unwrap(), MemoryValue::Address(new_fp))],
         );
         // Define a JNZ instruction where `updated_fp` points to the new address in memory.
         let instruction = Instruction::JumpIfNotZero {
@@ -576,7 +572,7 @@ mod tests {
         let mut vm = setup_vm(
             MemoryAddress::new(0, 0),
             fp,
-            &[(fp.add_usize(3).unwrap(), MemoryValue::Int(F::from_u64(99)))],
+            &[((fp + 3).unwrap(), MemoryValue::Int(F::from_u64(99)))],
         );
         // Define a JNZ instruction where `updated_fp` points to this integer value.
         let instruction = Instruction::JumpIfNotZero {

crates/leanVm/src/memory/address.rs

@@ -25,20 +25,6 @@ impl MemoryAddress {
             offset,
         }
     }
-
-    /// Add a `usize` to the address.
-    pub fn add_usize(self, other: usize) -> Result<Self, MathError> {
-        // Try to compute the new offset by adding `other` to the current offset.
-        //
-        // This uses `checked_add` to safely detect any potential `usize` overflow.
-        self.offset
-            .checked_add(other)
-            .map(|offset| Self {
-                segment_index: self.segment_index,
-                offset,
-            })
-            .ok_or_else(|| MathError::MemoryAddressAddUsizeOffsetExceeded(Box::new((self, other))))
-    }
 }
 
 impl Add<&F> for MemoryAddress {
@@ -63,6 +49,23 @@ impl Add<&F> for MemoryAddress {
     }
 }
 
+impl Add<usize> for MemoryAddress {
+    type Output = Result<Self, MathError>;
+
+    fn add(self, other: usize) -> Self::Output {
+        // Try to compute the new offset by adding `other` to the current offset.
+        //
+        // This uses `checked_add` to safely detect any potential `usize` overflow.
+        self.offset
+            .checked_add(other)
+            .map(|offset| Self {
+                segment_index: self.segment_index,
+                offset,
+            })
+            .ok_or_else(|| MathError::MemoryAddressAddUsizeOffsetExceeded(Box::new((self, other))))
+    }
+}
+
 impl Display for MemoryAddress {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}:{}", self.segment_index, self.offset)
@@ -113,7 +116,7 @@ mod tests {
             segment_index: 2,
             offset: 100,
         };
-        let result = addr.add_usize(25);
+        let result = addr + 25;
         assert_eq!(
             result,
             Ok(MemoryAddress {
@@ -129,7 +132,7 @@ mod tests {
             segment_index: 5,
             offset: 500,
         };
-        let result = addr.add_usize(0);
+        let result = addr + 0;
         assert_eq!(result, Ok(addr));
     }
 
@@ -139,7 +142,7 @@ mod tests {
             segment_index: 1,
             offset: usize::MAX,
         };
-        let result = addr.add_usize(1);
+        let result = addr + 1;
         match result {
             Err(MathError::MemoryAddressAddUsizeOffsetExceeded(boxed)) => {
                 let (original, added) = *boxed;
@@ -154,7 +157,7 @@ mod tests {
     proptest! {
         #[test]
         fn test_add_does_not_overflow(addr in any::<MemoryAddress>(), delta in 0usize..1_000_000) {
-            let result = addr.add_usize(delta);
+            let result = addr + delta;
             // Only test when offset + delta won't overflow
             if let Some(expected_offset) = addr.offset.checked_add(delta) {
                 prop_assert_eq!(result, Ok(MemoryAddress {

crates/leanVm/src/memory/manager.rs

@@ -80,7 +80,7 @@ impl MemoryManager {
             // Compute the target address: ptr + num.
             //
             // This operation may fail if it causes overflow.
-            let addr = ptr.add_usize(num).map_err(MemoryError::Math)?;
+            let addr = (ptr + num).map_err(MemoryError::Math)?;
 
             // Attempt to write the value into memory at the computed address.
             //
@@ -92,7 +92,7 @@ impl MemoryManager {
         // After writing all values, compute and return the address after the last item.
         //
         // This is simply ptr + data.len(), and it may also fail on overflow.
-        ptr.add_usize(data.len()).map_err(MemoryError::Math)
+        (ptr + data.len()).map_err(MemoryError::Math)
     }
 
     /// Retrieves the value stored at a given memory address.

crates/leanVm/src/memory/mem.rs

@@ -166,7 +166,7 @@ impl Memory {
         // Iterate from 0 to DIM-1 to read each element of the vector.
         for (i, res) in result.iter_mut().enumerate().take(DIM) {
             // Calculate the address of the current element by adding the index `i` to the start offset.
-            let current_addr = start_address.add_usize(i).map_err(MemoryError::Math)?;
+            let current_addr = (start_address + i).map_err(MemoryError::Math)?;
 
             // Retrieve the value from the calculated address.
             let mem_val = self
@@ -198,7 +198,7 @@ impl Memory {
         // Iterate from 0 to DIM-1 to read each element of the vector.
         for (i, o) in out.iter_mut().enumerate().take(DIM) {
             // Calculate the address of the current element by adding the index `i` to the start offset.
-            let addr = start_address.add_usize(i)?;
+            let addr = (start_address + i)?;
 
             // Attempt to retrieve the value from the memory and convert it into type `V`.
             let v = self
@@ -414,7 +414,7 @@ mod tests {
         for (i, &val) in values_to_insert.iter().enumerate() {
             memory
                 // Calculate the address for the current item: `start_addr + i`.
-                .insert(start_addr.add_usize(i).unwrap(), val)
+                .insert((start_addr + i).unwrap(), val)
                 .unwrap();
         }
 

crates/leanVm/src/memory/val.rs

@@ -75,7 +75,7 @@ impl Add<usize> for MemoryValue {
 
     fn add(self, rhs: usize) -> Self::Output {
         match self {
-            Self::Address(addr) => Ok(Self::Address(addr.add_usize(rhs)?)),
+            Self::Address(addr) => Ok(Self::Address((addr + rhs)?)),
             Self::Int(int) => Ok(Self::Int(int + F::from_usize(rhs))),
         }
     }