Use CairoArg enum instead of Any in CairoRunner::run_from_entrypoint

CHANGELOG.md

@@ -20,7 +20,7 @@
 
 * Default implementation of compile_hint [#680](https://github.com/lambdaclass/cairo-rs/pull/680)
     * Internal changes: 
-        * Make the `compile_hint` implementation which was in the `BuiltinHintProcessor` the default implementation in the trait. 
+        * Make the `compile_hint` implementation which was in the `BuiltinHintProcessor` the default implementation in the trait.
 
 * Add new error type `HintError` [#676](https://github.com/lambdaclass/cairo-rs/pull/676)
     * Public Api changes:
@@ -32,3 +32,12 @@
         * `DictManager`, its dictionaries, and all dict module hints implemented in rust now use `MaybeRelocatable` for keys and values instead of `BigInt`
         * Add helper functions that allow extracting ids variables as `MaybeRelocatable`: `get_maybe_relocatable_from_var_name` & `get_maybe_relocatable_from_reference`
         * Change inner value type of dict-related `HintError` variants to `MaybeRelocatable`
+
+* Use CairoArg enum instead of Any in CairoRunner::run_from_entrypoint [#686](https://github.com/lambdaclass/cairo-rs/pull/686)
+    * Public Api changes:
+        * Remove `Result` from `MaybeRelocatable::mod_floor`, it now returns a `MaybeRelocatable` 
+        * Add struct `CairoArg`
+        * Change `arg` argument of `CairoRunner::run_from_entrypoint` from `Vec<&dyn Any>` to `&[&CairoArg]`
+        * Remove argument `typed_args` from `CairoRunner::run_from_entrypoint`
+        * Remove no longer used method `gen_typed_arg` from `VirtualMachine` & `MemorySegmentManager`
+        * Add methods `MemorySegmentManager::gen_cairo_arg` & `MemorySegmentManager::write_simple_args` as typed counterparts to `MemorySegmentManager::gen_arg` & `MemorySegmentManager::write_arg`

src/vm/runners/cairo_runner.rs

@@ -44,6 +44,24 @@ use std::{
 
 use super::builtin_runner::KeccakBuiltinRunner;
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum CairoArg {
+    Single(MaybeRelocatable),
+    Array(Vec<MaybeRelocatable>),
+}
+
+impl From<MaybeRelocatable> for CairoArg {
+    fn from(other: MaybeRelocatable) -> Self {
+        CairoArg::Single(other)
+    }
+}
+
+impl From<Vec<MaybeRelocatable>> for CairoArg {
+    fn from(other: Vec<MaybeRelocatable>) -> Self {
+        CairoArg::Array(other)
+    }
+}
+
 pub struct CairoRunner {
     pub(crate) program: Program,
     layout: CairoLayout,
@@ -940,28 +958,15 @@ impl CairoRunner {
     pub fn run_from_entrypoint(
         &mut self,
         entrypoint: usize,
-        args: Vec<&dyn Any>,
-        typed_args: bool,
+        args: &[&CairoArg],
         verify_secure: bool,
-        _apply_modulo_to_args: bool,
         vm: &mut VirtualMachine,
         hint_processor: &mut dyn HintProcessor,
     ) -> Result<(), VirtualMachineError> {
-        let stack = if typed_args {
-            if args.len() != 1 {
-                return Err(VirtualMachineError::InvalidArgCount(1, args.len()));
-            }
-
-            vm.segments.gen_typed_args(args, vm)?
-        } else {
-            let mut stack = Vec::new();
-            for arg in args {
-                stack.push(vm.segments.gen_arg(arg, &mut vm.memory)?);
-            }
-
-            stack
-        };
-
+        let stack = args
+            .iter()
+            .map(|arg| vm.segments.gen_cairo_arg(arg, &mut vm.memory))
+            .collect::<Result<Vec<MaybeRelocatable>, VirtualMachineError>>()?;
         let return_fp = vm.segments.add(&mut vm.memory);
         let end = self.initialize_function_entrypoint(vm, entrypoint, stack, return_fp.into())?;
 
@@ -3336,116 +3341,6 @@ mod tests {
         );
     }
 
-    /// Test that the call to .run_from_entrypoint() with args.count() != 1 when
-    /// typed_args is true fails.
-    #[test]
-    fn run_from_entrypoint_typed_args_invalid_arg_count() {
-        let program =
-            Program::from_file(Path::new("cairo_programs/not_main.json"), Some("main")).unwrap();
-        let mut cairo_runner = cairo_runner!(program);
-        let mut vm = vm!();
-        let mut hint_processor = BuiltinHintProcessor::new_empty();
-
-        let entrypoint = program
-            .identifiers
-            .get("__main__.not_main")
-            .unwrap()
-            .pc
-            .unwrap();
-        assert_eq!(
-            cairo_runner.run_from_entrypoint(
-                entrypoint,
-                vec![],
-                true,
-                true,
-                true,
-                &mut vm,
-                &mut hint_processor,
-            ),
-            Err(VirtualMachineError::InvalidArgCount(1, 0)),
-        );
-        assert_eq!(
-            cairo_runner.run_from_entrypoint(
-                entrypoint,
-                vec![&mayberelocatable!(0), &mayberelocatable!(1)],
-                true,
-                true,
-                true,
-                &mut vm,
-                &mut hint_processor,
-            ),
-            Err(VirtualMachineError::InvalidArgCount(1, 2)),
-        );
-    }
-
-    /// Test that the call to .run_from_entrypoint() with args.count() == 1 when
-    /// typed_args is true succeeds.
-    #[test]
-    fn run_from_entrypoint_typed_args() {
-        let program =
-            Program::from_file(Path::new("cairo_programs/not_main.json"), Some("main")).unwrap();
-        let mut cairo_runner = cairo_runner!(program);
-        let mut vm = vm!();
-        let mut hint_processor = BuiltinHintProcessor::new_empty();
-
-        let entrypoint = program
-            .identifiers
-            .get("__main__.not_main")
-            .unwrap()
-            .pc
-            .unwrap();
-
-        vm.accessed_addresses = Some(Vec::new());
-        cairo_runner.initialize_builtins(&mut vm).unwrap();
-        cairo_runner.initialize_segments(&mut vm, None);
-        assert_eq!(
-            cairo_runner.run_from_entrypoint(
-                entrypoint,
-                vec![&mayberelocatable!(0)],
-                true,
-                true,
-                true,
-                &mut vm,
-                &mut hint_processor,
-            ),
-            Ok(()),
-        );
-    }
-
-    /// Test that the call to .run_from_entrypoint() when typed_args is false
-    /// succeeds.
-    #[test]
-    fn run_from_entrypoint_untyped_args() {
-        let program =
-            Program::from_file(Path::new("cairo_programs/not_main.json"), Some("main")).unwrap();
-        let mut cairo_runner = cairo_runner!(program);
-        let mut vm = vm!();
-        let mut hint_processor = BuiltinHintProcessor::new_empty();
-
-        let entrypoint = program
-            .identifiers
-            .get("__main__.not_main")
-            .unwrap()
-            .pc
-            .unwrap();
-
-        vm.accessed_addresses = Some(Vec::new());
-        cairo_runner.initialize_builtins(&mut vm).unwrap();
-        cairo_runner.initialize_segments(&mut vm, None);
-        assert_eq!(
-            cairo_runner.run_from_entrypoint(
-                entrypoint,
-                vec![],
-                false,
-                true,
-                true,
-                &mut vm,
-                &mut hint_processor,
-            ),
-            Ok(()),
-        );
-    }
-
     #[test]
     fn finalize_segments_run_not_ended() {
         let program = program!();
@@ -4232,9 +4127,10 @@ mod tests {
         assert_eq!(
             cairo_runner.run_from_entrypoint(
                 main_entrypoint,
-                vec![&mayberelocatable!(2), &MaybeRelocatable::from((2, 0))], //range_check_ptr
-                false,
-                true,
+                &vec![
+                    &mayberelocatable!(2).into(),
+                    &MaybeRelocatable::from((2, 0)).into()
+                ], //range_check_ptr
                 true,
                 &mut vm,
                 &mut hint_processor,
@@ -4260,14 +4156,29 @@ mod tests {
         assert_eq!(
             new_cairo_runner.run_from_entrypoint(
                 fib_entrypoint,
-                vec![&mayberelocatable!(2), &MaybeRelocatable::from((2, 0))],
-                false,
-                true,
+                &vec![
+                    &mayberelocatable!(2).into(),
+                    &MaybeRelocatable::from((2, 0)).into()
+                ],
                 true,
                 &mut new_vm,
                 &mut hint_processor,
             ),
             Ok(()),
         );
     }
+
+    #[test]
+    fn cairo_arg_from_single() {
+        let expected = CairoArg::Single(MaybeRelocatable::from((0, 0)));
+        let value = MaybeRelocatable::from((0, 0));
+        assert_eq!(expected, value.into())
+    }
+
+    #[test]
+    fn cairo_arg_from_array() {
+        let expected = CairoArg::Array(vec![MaybeRelocatable::from((0, 0))]);
+        let value = vec![MaybeRelocatable::from((0, 0))];
+        assert_eq!(expected, value.into())
+    }
 }

src/vm/vm_core.rs

@@ -965,13 +965,6 @@ impl VirtualMachine {
         self.memory.add_relocation_rule(src_ptr, dst_ptr)
     }
 
-    pub fn gen_typed_args(
-        &self,
-        args: Vec<&dyn Any>,
-    ) -> Result<Vec<MaybeRelocatable>, VirtualMachineError> {
-        self.segments.gen_typed_args(args, self)
-    }
-
     pub fn gen_arg(&mut self, arg: &dyn Any) -> Result<MaybeRelocatable, VirtualMachineError> {
         self.segments.gen_arg(arg, &mut self.memory)
     }
@@ -3774,56 +3767,6 @@ mod tests {
         );
     }
 
-    /// Test that the call to .gen_arg() with any other argument returns a not
-    /// implemented error.
-    #[test]
-    fn gen_arg_not_implemented() {
-        let mut vm = vm!();
-
-        assert_eq!(vm.gen_arg(&""), Err(VirtualMachineError::NotImplemented),);
-    }
-
-    #[test]
-    fn gen_typed_args_empty() {
-        let vm = vm!();
-
-        assert_eq!(vm.gen_typed_args(vec![]), Ok(vec![]));
-    }
-
-    /// Test that the call to .gen_typed_args() with an unsupported vector
-    /// returns a not implemented error.
-    #[test]
-    fn gen_typed_args_not_implemented() {
-        let vm = vm!();
-
-        assert_eq!(
-            vm.gen_typed_args(vec![&0usize]),
-            Err(VirtualMachineError::NotImplemented),
-        );
-    }
-
-    /// Test that the call to .gen_typed_args() with a Vec<MaybeRelocatable>
-    /// with a relocatables returns the original contents.
-    #[test]
-    fn gen_typed_args_relocatable_slice() {
-        let vm = vm!();
-
-        assert_eq!(
-            vm.gen_typed_args(vec![&[
-                mayberelocatable!(0, 0),
-                mayberelocatable!(0, 1),
-                mayberelocatable!(0, 2),
-            ]
-            .into_iter()
-            .collect::<Vec<MaybeRelocatable>>(),]),
-            Ok(vec![
-                mayberelocatable!(0, 0),
-                mayberelocatable!(0, 1),
-                mayberelocatable!(0, 2),
-            ]),
-        );
-    }
-
     /// Test that compute_effective_sizes() works as intended.
     #[test]
     fn compute_effective_sizes() {