Add box tests for local_into_box

Author: Gilad Chase

corelib/src/test.cairo

@@ -37,6 +37,7 @@ mod to_byte_array_test;
 /// Tests for language features, without mixing implementations within the corelib.
 mod language_features {
     mod block_level_items_test;
+    mod box_test;
     mod closure_test;
     mod const_folding_test;
     mod const_test;

corelib/src/test/language_features/box_test.cairo

@@ -0,0 +1,18 @@
+extern fn local_into_box<T>(value: T) -> Box<T> nopanic;
+
+/// Boxes a value by storing it in a local variable first (via calling conventions), then delegating
+/// to `local_into_box` which expects a local.
+#[inline(never)]
+pub fn into_box<T>(value: T) -> Box<T> {
+    local_into_box(value)
+}
+
+#[test]
+fn test_local_into_box() {
+    assert_eq!(into_box((1, 2_u256, 3)).unbox(), (1, 2, 3));
+    assert_eq!(into_box(()).unbox(), ());
+    assert_eq!(into_box(Some(6_u8)).unbox(), Some(6));
+    assert_eq!(into_box(None::<u8>).unbox(), None);
+    assert_eq!(into_box(Ok::<u16, u256>(7)).unbox(), Ok(7));
+    assert_eq!(into_box(Err::<u16, u256>(8)).unbox(), Err(8));
+}

crates/cairo-lang-sierra-to-casm/src/invocations/boxing.rs

@@ -63,16 +63,20 @@ fn build_local_into_box(
 ) -> Result<CompiledInvocation, InvocationError> {
     let [operand] = builder.try_get_refs()?;
 
-    let base_offset = match &operand.cells[..] {
-        [] => 0,
-        [CellExpression::Deref(cell), ..] if cell.register == Register::FP => cell.offset.into(),
-        _ => return Err(InvocationError::InvalidReferenceExpressionForArgument),
-    };
     let cell = CellRef { register: Register::AP, offset: -2 };
-    let addr = CellExpression::BinOp {
-        op: CellOperator::Add,
-        a: cell,
-        b: DerefOrImmediate::Immediate(base_offset.into()),
+    let addr = match operand.cells.as_slice() {
+        [] | [CellExpression::Deref(CellRef { register: Register::FP, offset: 0 }), ..] => {
+            CellExpression::Deref(cell)
+        }
+        [CellExpression::Deref(CellRef { register: Register::FP, offset }), ..] => {
+            CellExpression::BinOp {
+                op: CellOperator::Add,
+                a: cell,
+                b: DerefOrImmediate::Immediate((*offset).into()),
+            }
+        }
+
+        _ => return Err(InvocationError::InvalidReferenceExpressionForArgument),
     };
     Ok(builder.build(
         casm!(call rel 0;).instructions,

tests/e2e_test_data/libfuncs/box

@@ -728,3 +728,111 @@ return([3]);
 
 test::helper@F0() -> (Box<test::A>);
 test::foo@F1() -> (Tuple<Box<core::integer::u256>, Box<core::integer::u256>>);
+
+//! > ==========================================================================
+
+//! > local_into_box with fp-based variable
+
+//! > test_runner_name
+SmallE2ETestRunner
+
+//! > cairo_code
+extern fn local_into_box<T>(value: T) -> Box<T> nopanic;
+fn foo(x: felt252) -> Box<felt252> {
+    local_into_box(x)
+}
+
+//! > casm
+call rel 5;
+[ap + 0] = [ap + -2] + -3, ap++;
+ret;
+
+//! > function_costs
+test::foo: SmallOrderedMap({Const: 400})
+
+//! > sierra_code
+type felt252 = felt252 [storable: true, drop: true, dup: true, zero_sized: false];
+type Box<felt252> = Box<felt252> [storable: true, drop: true, dup: true, zero_sized: false];
+
+libfunc local_into_box<felt252> = local_into_box<felt252>;
+libfunc store_temp<Box<felt252>> = store_temp<Box<felt252>>;
+
+F0:
+local_into_box<felt252>([0]) -> ([1]);
+store_temp<Box<felt252>>([1]) -> ([1]);
+return([1]);
+
+test::foo@F0([0]: felt252) -> (Box<felt252>);
+
+//! > ==========================================================================
+
+//! > reference operator with zero-sized type
+
+//! > test_runner_name
+SmallE2ETestRunner
+
+//! > cairo_code
+extern fn local_into_box<T>(value: T) -> Box<T> nopanic;
+fn foo(x: ()) -> Box<()> {
+    local_into_box(x)
+}
+
+//! > casm
+call rel 4;
+[ap + 0] = [ap + -2], ap++;
+ret;
+
+//! > function_costs
+test::foo: SmallOrderedMap({Const: 400})
+
+//! > sierra_code
+type Unit = Struct<ut@Tuple> [storable: true, drop: true, dup: true, zero_sized: true];
+type Box<Unit> = Box<Unit> [storable: true, drop: true, dup: true, zero_sized: false];
+
+libfunc local_into_box<Unit> = local_into_box<Unit>;
+libfunc store_temp<Box<Unit>> = store_temp<Box<Unit>>;
+
+F0:
+local_into_box<Unit>([0]) -> ([1]);
+store_temp<Box<Unit>>([1]) -> ([1]);
+return([1]);
+
+test::foo@F0([0]: Unit) -> (Box<Unit>);
+
+//! > ==========================================================================
+
+//! > reference operator non-local zero-sized type
+
+//! > test_runner_name
+SmallE2ETestRunner
+
+//! > cairo_code
+extern fn local_into_box<T>(value: T) -> Box<T> nopanic;
+
+fn foo() -> Box<()> {
+    local_into_box(())
+}
+
+//! > casm
+call rel 4;
+[ap + 0] = [ap + -2], ap++;
+ret;
+
+//! > sierra_code
+type Unit = Struct<ut@Tuple> [storable: true, drop: true, dup: true, zero_sized: true];
+type Box<Unit> = Box<Unit> [storable: true, drop: true, dup: true, zero_sized: false];
+
+libfunc struct_construct<Unit> = struct_construct<Unit>;
+libfunc local_into_box<Unit> = local_into_box<Unit>;
+libfunc store_temp<Box<Unit>> = store_temp<Box<Unit>>;
+
+F0:
+struct_construct<Unit>() -> ([0]);
+local_into_box<Unit>([0]) -> ([1]);
+store_temp<Box<Unit>>([1]) -> ([1]);
+return([1]);
+
+test::foo@F0() -> (Box<Unit>);
+
+//! > function_costs
+test::foo: SmallOrderedMap({Const: 400})