Return MaybeRelocatable directly from Memory::get instead of Cow

vm/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs

@@ -16,7 +16,7 @@ use crate::{
     Felt252,
 };
 use num_traits::ToPrimitive;
-use std::{borrow::Cow, collections::HashMap};
+use std::collections::HashMap;
 
 // Constants in package "starkware.cairo.common.cairo_keccak.keccak".
 const BYTES_IN_WORD: &str = "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD";
@@ -335,18 +335,15 @@ pub(crate) fn cairo_keccak_finalize_v2(
 // Helper function to transform a vector of MaybeRelocatables into a vector
 // of u64. Raises error if there are None's or if MaybeRelocatables are not Bigints.
 pub(crate) fn maybe_reloc_vec_to_u64_array(
-    vec: &[Option<Cow<MaybeRelocatable>>],
+    vec: &[Option<MaybeRelocatable>],
 ) -> Result<Vec<u64>, HintError> {
     let array = vec
         .iter()
         .map(|n| match n {
-            Some(Cow::Owned(MaybeRelocatable::Int(ref num)))
-            | Some(Cow::Borrowed(MaybeRelocatable::Int(ref num))) => num
+            Some(MaybeRelocatable::Int(ref num)) => num
                 .to_u64()
                 .ok_or_else(|| MathError::Felt252ToU64Conversion(Box::new(*num)).into()),
-            _ => Err(VirtualMachineError::ExpectedIntAtRange(Box::new(
-                n.as_ref().map(|x| x.as_ref().to_owned()),
-            ))),
+            _ => Err(VirtualMachineError::ExpectedIntAtRange(Box::new(n.clone()))),
         })
         .collect::<Result<Vec<u64>, VirtualMachineError>>()?;
 

vm/src/hint_processor/builtin_hint_processor/dict_hint_utils.rs

@@ -351,9 +351,8 @@ mod tests {
             vm.segments
                 .memory
                 .get(&MaybeRelocatable::from((1, 1)))
-                .unwrap()
-                .as_ref(),
-            &MaybeRelocatable::from(12)
+                .unwrap(),
+            MaybeRelocatable::from(12)
         );
         //Check that the tracker's current_ptr has moved accordingly
         check_dict_ptr!(&exec_scopes, 2, (2, 3));

vm/src/hint_processor/builtin_hint_processor/set.rs

@@ -121,9 +121,8 @@ mod tests {
             vm.segments
                 .memory
                 .get(&MaybeRelocatable::from((1, 0)))
-                .unwrap()
-                .as_ref(),
-            &MaybeRelocatable::Int(Felt252::ZERO)
+                .unwrap(),
+            MaybeRelocatable::Int(Felt252::ZERO)
         )
     }
 

vm/src/tests/segment_arena_test.rs

@@ -1,7 +1,7 @@
 // This test mirrors the test on cairo-lang for segment_arena
 // https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/builtins/segment_arena/segment_arena_test.py
 use crate::types::layout_name::LayoutName;
-use std::{borrow::Cow, collections::HashMap, rc::Rc};
+use std::{collections::HashMap, rc::Rc};
 
 use crate::any_box;
 use crate::cairo_run::{cairo_run, CairoRunConfig};
@@ -174,7 +174,7 @@ fn test_segment_arena() {
         Some(7),
     ]
     .into_iter()
-    .map(|val| val.map(|int| Cow::Owned(MaybeRelocatable::Int(Felt252::from(int)))))
+    .map(|val| val.map(|int| MaybeRelocatable::Int(Felt252::from(int))))
     .collect();
 
     assert_eq!(concat_segments_data, expected_concat_segment_data);
@@ -200,7 +200,7 @@ fn test_segment_arena() {
         MaybeRelocatable::Int(Felt252::from(2)),
     ]
     .into_iter()
-    .map(|val| Some(Cow::Owned::<MaybeRelocatable>(val)))
+    .map(|val| Some(val))
     .collect();
 
     assert_eq!(infos_data, expected_infos_data);

vm/src/utils.rs

@@ -197,14 +197,14 @@ pub mod test_utils {
     macro_rules! check_memory_address {
         ($mem:expr, ($si:expr, $off:expr), ($sival:expr, $offval: expr)) => {
             assert_eq!(
-                $mem.get(&mayberelocatable!($si, $off)).unwrap().as_ref(),
-                &mayberelocatable!($sival, $offval)
+                $mem.get(&mayberelocatable!($si, $off)).unwrap(),
+                mayberelocatable!($sival, $offval)
             )
         };
         ($mem:expr, ($si:expr, $off:expr), $val:expr) => {
             assert_eq!(
-                $mem.get(&mayberelocatable!($si, $off)).unwrap().as_ref(),
-                &mayberelocatable!($val)
+                $mem.get(&mayberelocatable!($si, $off)).unwrap(),
+                mayberelocatable!($val)
             )
         };
     }

vm/src/vm/runners/builtin_runner/ec_op.rs

@@ -125,15 +125,13 @@ impl EcOpBuiltinRunner {
         for i in 0..INPUT_CELLS_PER_EC_OP as usize {
             match memory.get(&(instance + i)?) {
                 None => return Ok(None),
-                Some(addr) => {
-                    input_cells.push(match addr.as_ref() {
-                        MaybeRelocatable::Int(num) => *num,
-                        _ => {
-                            return Err(RunnerError::Memory(MemoryError::ExpectedInteger(
-                                Box::new((instance + i)?),
-                            )))
-                        }
-                    });
+                Some(MaybeRelocatable::Int(num)) => {
+                    input_cells.push(num);
+                }
+                Some(_) => {
+                    return Err(RunnerError::Memory(MemoryError::ExpectedInteger(Box::new(
+                        (instance + i)?,
+                    ))))
                 }
             };
         }

vm/src/vm/runners/builtin_runner/hash.rs

@@ -78,18 +78,17 @@ impl HashBuiltinRunner {
             segment_index: address.segment_index,
             offset: address.offset - 2,
         }));
-        if let (Some(MaybeRelocatable::Int(num_a)), Some(MaybeRelocatable::Int(num_b))) = (
-            num_a.as_ref().map(|x| x.as_ref()),
-            num_b.as_ref().map(|x| x.as_ref()),
-        ) {
+        if let (Some(MaybeRelocatable::Int(num_a)), Some(MaybeRelocatable::Int(num_b))) =
+            (num_a, num_b)
+        {
             if self.verified_addresses.borrow().len() <= address.offset {
                 self.verified_addresses
                     .borrow_mut()
                     .resize(address.offset + 1, false);
             }
             self.verified_addresses.borrow_mut()[address.offset] = true;
             //Compute pedersen Hash
-            let result = starknet_types_core::hash::Pedersen::hash(num_b, num_a);
+            let result = starknet_types_core::hash::Pedersen::hash(&num_b, &num_a);
             return Ok(Some(MaybeRelocatable::from(result)));
         }
         Ok(None)

vm/src/vm/runners/builtin_runner/modulo.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, collections::BTreeMap};
+use std::collections::BTreeMap;
 
 use crate::{
     air_private_input::{ModInput, ModInputInstance, ModInputMemoryVars, PrivateInput},
@@ -283,7 +283,7 @@ impl ModBuiltinRunner {
         let mut value = BigUint::zero();
         for i in 0..N_WORDS {
             let addr_i = (addr + i)?;
-            match memory.get(&addr_i).map(Cow::into_owned) {
+            match memory.get(&addr_i) {
                 None => return Ok((words, None)),
                 Some(MaybeRelocatable::RelocatableValue(_)) => {
                     return Err(MemoryError::ExpectedInteger(Box::new(addr_i)).into())
@@ -411,8 +411,7 @@ impl ModBuiltinRunner {
             let addr = (offsets_ptr + i)?;
             let offset = memory
                 .get(&((offsets_ptr + i)?))
-                .ok_or_else(|| MemoryError::UnknownMemoryCell(Box::new(addr)))?
-                .into_owned();
+                .ok_or_else(|| MemoryError::UnknownMemoryCell(Box::new(addr)))?;
             for copy_i in 0..n_copies {
                 memory.insert_as_accessed((offsets_ptr + (3 * (index + copy_i) + i))?, &offset)?;
             }

vm/src/vm/vm_core.rs

@@ -731,15 +731,15 @@ impl VirtualMachine {
     ) -> Result<(Operands, OperandsAddresses, DeducedOperands), VirtualMachineError> {
         //Get operands from memory
         let dst_addr = self.run_context.compute_dst_addr(instruction)?;
-        let dst_op = self.segments.memory.get(&dst_addr).map(Cow::into_owned);
+        let dst_op = self.segments.memory.get(&dst_addr);
 
         let op0_addr = self.run_context.compute_op0_addr(instruction)?;
-        let op0_op = self.segments.memory.get(&op0_addr).map(Cow::into_owned);
+        let op0_op = self.segments.memory.get(&op0_addr);
 
         let op1_addr = self
             .run_context
             .compute_op1_addr(instruction, op0_op.as_ref())?;
-        let op1_op = self.segments.memory.get(&op1_addr).map(Cow::into_owned);
+        let op1_op = self.segments.memory.get(&op1_addr);
 
         let mut res: Option<MaybeRelocatable> = None;
 
@@ -885,7 +885,7 @@ impl VirtualMachine {
             None => return Ok(()),
         };
         let current_value = match self.segments.memory.get(&addr) {
-            Some(value) => value.into_owned(),
+            Some(value) => value,
             None => return Ok(()),
         };
         if value != current_value {
@@ -1022,7 +1022,7 @@ impl VirtualMachine {
     where
         Relocatable: TryFrom<&'a K>,
     {
-        self.segments.memory.get(key).map(|x| x.into_owned())
+        self.segments.memory.get(key)
     }
 
     /// Returns a reference to the vector with all builtins present in the virtual machine
@@ -1106,11 +1106,7 @@ impl VirtualMachine {
     }
 
     ///Gets n elements from memory starting from addr (n being size)
-    pub fn get_range(
-        &'_ self,
-        addr: Relocatable,
-        size: usize,
-    ) -> Vec<Option<Cow<'_, MaybeRelocatable>>> {
+    pub fn get_range(&self, addr: Relocatable, size: usize) -> Vec<Option<MaybeRelocatable>> {
         self.segments.memory.get_range(addr, size)
     }
 
@@ -1256,8 +1252,8 @@ impl VirtualMachine {
                 .memory
                 .get(&Relocatable::from((segment_index as isize, i)))
             {
-                Some(val) => match val.as_ref() {
-                    MaybeRelocatable::Int(num) => format!("{}", signed_felt(*num)),
+                Some(val) => match val {
+                    MaybeRelocatable::Int(num) => format!("{}", signed_felt(num)),
                     MaybeRelocatable::RelocatableValue(rel) => format!("{}", rel),
                 },
                 _ => "<missing>".to_string(),
@@ -3746,12 +3742,8 @@ mod tests {
         assert_eq!(vm.run_context.ap, 2);
 
         assert_eq!(
-            vm.segments
-                .memory
-                .get(&vm.run_context.get_ap())
-                .unwrap()
-                .as_ref(),
-            &MaybeRelocatable::Int(Felt252::from(0x4)),
+            vm.segments.memory.get(&vm.run_context.get_ap()).unwrap(),
+            MaybeRelocatable::Int(Felt252::from(0x4)),
         );
         let mut hint_processor = BuiltinHintProcessor::new_empty();
         assert_matches!(
@@ -3770,12 +3762,8 @@ mod tests {
         assert_eq!(vm.run_context.ap, 3);
 
         assert_eq!(
-            vm.segments
-                .memory
-                .get(&vm.run_context.get_ap())
-                .unwrap()
-                .as_ref(),
-            &MaybeRelocatable::Int(Felt252::from(0x5))
+            vm.segments.memory.get(&vm.run_context.get_ap()).unwrap(),
+            MaybeRelocatable::Int(Felt252::from(0x5))
         );
 
         let mut hint_processor = BuiltinHintProcessor::new_empty();
@@ -3795,12 +3783,8 @@ mod tests {
         assert_eq!(vm.run_context.ap, 4);
 
         assert_eq!(
-            vm.segments
-                .memory
-                .get(&vm.run_context.get_ap())
-                .unwrap()
-                .as_ref(),
-            &MaybeRelocatable::Int(Felt252::from(0x14)),
+            vm.segments.memory.get(&vm.run_context.get_ap()).unwrap(),
+            MaybeRelocatable::Int(Felt252::from(0x14)),
         );
     }
 
@@ -4423,11 +4407,7 @@ mod tests {
         let value2 = MaybeRelocatable::from(Felt252::from(3_i32));
         let value3 = MaybeRelocatable::from(Felt252::from(4_i32));
 
-        let expected_vec = vec![
-            Some(Cow::Borrowed(&value1)),
-            Some(Cow::Borrowed(&value2)),
-            Some(Cow::Borrowed(&value3)),
-        ];
+        let expected_vec = vec![Some(value1), Some(value2), Some(value3)];
         assert_eq!(vm.get_range(Relocatable::from((1, 0)), 3), expected_vec);
     }
 
@@ -4440,12 +4420,7 @@ mod tests {
         let value2 = MaybeRelocatable::from(Felt252::from(3_i32));
         let value3 = MaybeRelocatable::from(Felt252::from(4_i32));
 
-        let expected_vec = vec![
-            Some(Cow::Borrowed(&value1)),
-            Some(Cow::Borrowed(&value2)),
-            None,
-            Some(Cow::Borrowed(&value3)),
-        ];
+        let expected_vec = vec![Some(value1), Some(value2), None, Some(value3)];
         assert_eq!(vm.get_range(Relocatable::from((1, 0)), 4), expected_vec);
     }