const.rs + some unhanled cases in value.rs -> to_ptr

lambdaclass · Jan 23, 2025 · eda0803 · eda0803
1 parent 615ac6d
commit eda0803
Show file tree

Hide file tree

Showing 5 changed files with 93 additions and 17 deletions.
diff --git a/program.cairo b/program.cairo
@@ -0,0 +1,12 @@
+use core::box::BoxTrait;
+
+struct Hello {
+    x: i32,
+}
+
+fn run_test() -> Hello {
+    let x = BoxTrait::new(Hello {
+        x: -2
+    });
+    x.unbox()
+}
diff --git a/src/libfuncs/bool.rs b/src/libfuncs/bool.rs
@@ -209,10 +209,15 @@ pub fn build_bool_to_felt252<'ctx, 'this>(
 
 #[cfg(test)]
 mod test {
-    use cairo_lang_sierra::extensions::boolean::{BoolAndLibfunc, BoolNotLibfunc, BoolOrLibfunc, BoolToFelt252Libfunc, BoolXorLibfunc};
+    use cairo_lang_sierra::extensions::boolean::{
+        BoolAndLibfunc, BoolNotLibfunc, BoolOrLibfunc, BoolToFelt252Libfunc, BoolXorLibfunc,
+    };
 
     use crate::{
-        utils::{sierra_gen::SierraGenerator, test::{jit_enum, jit_struct, load_cairo, run_program, run_sierra_program}},
+        utils::{
+            sierra_gen::SierraGenerator,
+            test::{jit_enum, jit_struct, load_cairo, run_program, run_sierra_program},
+        },
         values::Value,
     };
 

diff --git a/src/libfuncs/const.rs b/src/libfuncs/const.rs
@@ -308,29 +308,78 @@ pub fn build_const_type_value<'ctx, 'this>(
 
 #[cfg(test)]
 pub mod test {
+    use cairo_lang_sierra::{
+        extensions::{
+            boxing::UnboxLibfunc,
+            const_type::{ConstAsBoxLibfunc, ConstType},
+            int::signed::Sint32Type,
+            structure::StructType,
+        },
+        ids::UserTypeId,
+        program::GenericArg,
+    };
+
     use crate::{
-        utils::test::{jit_struct, load_cairo, run_program},
+        utils::{
+            sierra_gen::SierraGenerator,
+            test::{jit_struct, run_sierra_program},
+        },
         values::Value,
     };
 
     #[test]
     fn run_const_as_box() {
-        let program = load_cairo!(
-            use core::box::BoxTrait;
+        let program_as_const = {
+            let mut generator = SierraGenerator::<ConstAsBoxLibfunc>::default();
 
-            struct Hello {
-                x: i32,
-            }
+            let i32_ty = generator.push_type_declaration::<Sint32Type>(&[]).clone();
 
-            fn run_test() -> Hello {
-                let x = BoxTrait::new(Hello {
-                    x: -2
-                });
-                x.unbox()
-            }
-        );
+            let const_i32_ty = generator
+                .push_type_declaration::<ConstType>(&[
+                    GenericArg::Type(i32_ty.clone()),
+                    GenericArg::Value((-2).into()),
+                ])
+                .clone();
+
+            let struct_ty = generator
+                .push_type_declaration::<StructType>(&[
+                    GenericArg::UserType(UserTypeId::from_string("Hello")),
+                    GenericArg::Type(i32_ty),
+                ])
+                .clone();
+
+            let const_struct_ty = generator
+                .push_type_declaration::<ConstType>(&[
+                    GenericArg::Type(struct_ty),
+                    GenericArg::Type(const_i32_ty.clone()),
+                ])
+                .clone();
+
+            generator.build(&[
+                GenericArg::Type(const_struct_ty),
+                GenericArg::Value(0.into()),
+            ])
+        };
+
+        let program_unbox = {
+            let mut generator = SierraGenerator::<UnboxLibfunc>::default();
+
+            let i32_type = generator.push_type_declaration::<Sint32Type>(&[]).clone();
+
+            let struct_type = generator
+                .push_type_declaration::<StructType>(&[
+                    GenericArg::UserType(UserTypeId::from_string("Hello")),
+                    GenericArg::Type(i32_type),
+                ])
+                .clone();
+
+            generator.build(&[GenericArg::Type(struct_type)])
+        };
+
+        let result = run_sierra_program(&program_as_const, &[]).return_value;
+
+        let result = run_sierra_program(&program_unbox, &[result]).return_value;
 
-        let result = run_program(&program, "run_test", &[]).return_value;
         assert_eq!(result, jit_struct!(Value::Sint32(-2)));
     }
 }
diff --git a/src/utils/sierra_gen.rs b/src/utils/sierra_gen.rs
@@ -522,7 +522,7 @@ mod test {
     #[test]
     fn sierra_generator_type_info() {
         let program = {
-            let mut generator = SierraGenerator::<BoundedIntTrimLibfunc>::default();
+            let mut generator = SierraGenerator::<BoundedIntTrimLibfunc<true>>::default();
 
             let u32_type = generator.push_type_declaration::<Uint32Type>(&[]).clone();
 

diff --git a/src/values.rs b/src/values.rs
@@ -176,6 +176,16 @@ impl Value {
     ) -> Result<NonNull<()>, Error> {
         let ty = registry.get_type(type_id)?;
 
+        match ty {
+            CoreTypeConcrete::Box(info)
+            | CoreTypeConcrete::NonZero(info)
+            | CoreTypeConcrete::Nullable(info)
+            | CoreTypeConcrete::Snapshot(info) => {
+                return self.to_ptr(arena, registry, &info.ty, find_dict_overrides);
+            }
+            _ => {}
+        }
+
         Ok(unsafe {
             match self {
                 Self::Felt252(value) => {