(optimization): Reboxing also applied on Box of snapshots

Author: eytan-starkware

crates/cairo-lang-lowering/src/optimizations/reboxing.rs

@@ -8,7 +8,7 @@ use std::rc::Rc;
 use cairo_lang_filesystem::flag::flag_future_sierra;
 use cairo_lang_semantic::helper::ModuleHelper;
 use cairo_lang_semantic::items::structure::StructSemantic;
-use cairo_lang_semantic::types::{TypesSemantic, peel_snapshots};
+use cairo_lang_semantic::types::{TypesSemantic, peel_snapshots, wrap_in_snapshots};
 use cairo_lang_semantic::{ConcreteTypeId, GenericArgumentId, TypeId, TypeLongId};
 use cairo_lang_utils::ordered_hash_map::{Entry, OrderedHashMap};
 use cairo_lang_utils::ordered_hash_set::OrderedHashSet;
@@ -255,7 +255,7 @@ fn create_struct_boxed_deconstruct_call<'db>(
     old_stmt: &Statement<'db>,
 ) -> Option<Statement<'db>> {
     // TODO(eytan-starkware): Accept a collection of vars to create a box of. A single call to
-    // struct_boxed_deconstruct can be created for multiple vars.       When creating multivars
+    // struct_boxed_deconstruct can be created for multiple vars. When creating multivars
     // we need to put creation at a dominating point.
 
     let boxed_struct_ty = variables[boxed_struct_var].ty;
@@ -277,26 +277,25 @@ fn create_struct_boxed_deconstruct_call<'db>(
     }
     let (n_snapshots, struct_ty) = peel_snapshots(db, *inner_ty);
 
-    // TODO(eytan-starkware): Support snapshots of structs in reboxing optimization.
-    // Currently we give up if the struct is wrapped in snapshots.
-    if n_snapshots > 0 {
-        trace!("Skipping reboxing for snapshotted struct (n_snapshots={})", n_snapshots);
-        return None;
-    }
-
     trace!("Extracted struct or tuple type: {:?}", struct_ty);
 
     // Get the type info to determine number of members
     let (num_members, member_types): (usize, Vec<TypeId<'_>>) = match struct_ty {
         TypeLongId::Concrete(ConcreteTypeId::Struct(struct_id)) => {
             let members = db.concrete_struct_members(struct_id).ok()?;
             let num = members.len();
-            let types = members.iter().map(|(_, member)| member.ty).collect();
+            let types = members
+                .iter()
+                .map(|(_, member)| wrap_in_snapshots(db, member.ty, n_snapshots))
+                .collect();
             (num, types)
         }
         TypeLongId::Tuple(inner_types) => {
             let num = inner_types.len();
-            (num, inner_types)
+            (
+                num,
+                inner_types.into_iter().map(|ty| wrap_in_snapshots(db, ty, n_snapshots)).collect(),
+            )
         }
         _ => {
             trace!("Unsupported type for reboxing: {:?}", struct_ty);

crates/cairo-lang-lowering/src/optimizations/test_data/reboxing

@@ -225,7 +225,7 @@ blk0 (root):
 Statements:
   (v1: @test::Data) <- core::box::unbox::<@test::Data>(v0)
   (v2: @test::NonCopy, v3: @core::felt252) <- struct_destructure(v1)
-  (v4: core::box::Box::<@test::NonCopy>) <- core::box::into_box::<@test::NonCopy>(v2)
+  (v4: core::box::Box::<@test::NonCopy>, v5: core::box::Box::<@core::felt252>) <- struct_destructure(v0)
 End:
   Return(v4)
 
@@ -779,3 +779,68 @@ Statements:
   (v5: (core::box::Box::<core::felt252>, test::NonDrop)) <- struct_construct(v4, v3)
 End:
   Return(v5)
+
+//! > ==========================================================================
+
+//! > Test reboxing with snapshot of non-drop struct and member
+
+//! > test_runner_name
+test_reboxing_analysis
+
+//! > function_name
+main
+
+//! > module_code
+use core::box::BoxTrait;
+
+#[derive(Copy)]
+struct NonDrop {
+    b: felt252,
+}
+
+#[derive(Copy)]
+struct A {
+    a: felt252,
+    non_drop: NonDrop,
+}
+
+//! > function_code
+fn main(a: @A) -> (Box<@felt252>, @NonDrop) {
+    let boxed = BoxTrait::new(a);
+    let unboxed = boxed.unbox();
+    let member_a = unboxed.a;
+    (BoxTrait::new(member_a), unboxed.non_drop)
+}
+
+//! > semantic_diagnostics
+
+//! > lowering_diagnostics
+
+//! > candidates
+v5
+
+//! > before
+Parameters: v0: @test::A
+blk0 (root):
+Statements:
+  (v1: core::box::Box::<@test::A>) <- core::box::into_box::<@test::A>(v0)
+  (v2: @test::A) <- core::box::unbox::<@test::A>(v1)
+  (v3: @core::felt252, v4: @test::NonDrop) <- struct_destructure(v2)
+  (v5: core::box::Box::<@core::felt252>) <- core::box::into_box::<@core::felt252>(v3)
+  (v6: @core::felt252, v7: @test::NonDrop) <- struct_destructure(v2)
+  (v8: (core::box::Box::<@core::felt252>, @test::NonDrop)) <- struct_construct(v5, v7)
+End:
+  Return(v8)
+
+//! > after
+Parameters: v0: @test::A
+blk0 (root):
+Statements:
+  (v1: core::box::Box::<@test::A>) <- core::box::into_box::<@test::A>(v0)
+  (v2: @test::A) <- core::box::unbox::<@test::A>(v1)
+  (v3: @core::felt252, v4: @test::NonDrop) <- struct_destructure(v2)
+  (v5: core::box::Box::<@core::felt252>, v9: core::box::Box::<@test::NonDrop>) <- struct_destructure(v1)
+  (v6: @core::felt252, v7: @test::NonDrop) <- struct_destructure(v2)
+  (v8: (core::box::Box::<@core::felt252>, @test::NonDrop)) <- struct_construct(v5, v7)
+End:
+  Return(v8)

crates/cairo-lang-sierra-generator/src/function_generator_test_data/struct

@@ -118,18 +118,16 @@ struct A {
 
 //! > lowering_diagnostics
 
-//! > TODO(eytan-starkware): We want reboxing to apply to sierra in the future,
-//! > so we will see struct_boxed_deconstruct.
-
 //! > sierra_code
 label_test::foo::0:
 box_forward_snapshot<test::A>([0]) -> ([1])
-unbox<Snapshot<test::A>>([1]) -> ([2])
-store_temp<Snapshot<test::A>>([2]) -> ([2])
-struct_snapshot_deconstruct<test::A>([2]) -> ([3], [4])
-drop<Snapshot<Array<felt252>>>([4]) -> ()
-into_box<Snapshot<Array<felt252>>>([3]) -> ([5])
-return([5])
+dup<Box<Snapshot<test::A>>>([1]) -> ([1], [2])
+unbox<Snapshot<test::A>>([2]) -> ([3])
+drop<Snapshot<test::A>>([3]) -> ()
+struct_boxed_deconstruct<Snapshot<test::A>>([1]) -> ([4], [5])
+drop<Box<Snapshot<Array<felt252>>>>([5]) -> ()
+store_temp<Box<Snapshot<Array<felt252>>>>([4]) -> ([4])
+return([4])
 
 //! > ==========================================================================
 
@@ -157,14 +155,48 @@ struct A {
 
 //! > lowering_diagnostics
 
-//! > TODO(eytan-starkware): We want reboxing to apply to sierra in the future,
-//! > so we will see struct_boxed_deconstruct.
+//! > sierra_code
+label_test::foo::0:
+dup<Box<Snapshot<test::A>>>([0]) -> ([0], [1])
+unbox<Snapshot<test::A>>([1]) -> ([2])
+drop<Snapshot<test::A>>([2]) -> ()
+struct_boxed_deconstruct<Snapshot<test::A>>([0]) -> ([3], [4])
+drop<Box<Snapshot<Array<felt252>>>>([4]) -> ()
+store_temp<Box<Snapshot<Array<felt252>>>>([3]) -> ([3])
+return([3])
+
+//! > ==========================================================================
+
+//! > Test reboxing of a boxed, repeatedly snapshotted struct.
+
+//! > test_runner_name
+test_function_generator(future_sierra:true)
+
+//! > function_code
+fn foo(box: Box<@@@A>) -> Box<@@@Array<felt252>> {
+    BoxTrait::new(box.unbox().a)
+}
+
+//! > function_name
+foo
+
+//! > module_code
+#[derive(Drop)]
+struct A {
+    a: Array<felt252>,
+    b: Array<felt252>,
+}
+
+//! > semantic_diagnostics
+
+//! > lowering_diagnostics
 
 //! > sierra_code
 label_test::foo::0:
-unbox<Snapshot<test::A>>([0]) -> ([1])
-store_temp<Snapshot<test::A>>([1]) -> ([1])
-struct_snapshot_deconstruct<test::A>([1]) -> ([2], [3])
-drop<Snapshot<Array<felt252>>>([3]) -> ()
-into_box<Snapshot<Array<felt252>>>([2]) -> ([4])
-return([4])
+dup<Box<Snapshot<test::A>>>([0]) -> ([0], [1])
+unbox<Snapshot<test::A>>([1]) -> ([2])
+drop<Snapshot<test::A>>([2]) -> ()
+struct_boxed_deconstruct<Snapshot<test::A>>([0]) -> ([3], [4])
+drop<Box<Snapshot<Array<felt252>>>>([4]) -> ()
+store_temp<Box<Snapshot<Array<felt252>>>>([3]) -> ([3])
+return([3])

crates/cairo-lang-sierra-generator/src/utils.rs

@@ -112,9 +112,8 @@ pub fn struct_deconstruct_libfunc_id(
     let is_snapshot = long_id.generic_id == SnapshotType::id();
     let is_box = long_id.generic_id == BoxType::id();
     Ok(if is_snapshot {
-        let concrete_enum_type =
-            extract_matches!(&long_id.generic_args[0], GenericArg::Type).clone();
-        get_libfunc_id_with_generic_arg(db, "struct_snapshot_deconstruct", concrete_enum_type)
+        let concrete_type = extract_matches!(&long_id.generic_args[0], GenericArg::Type).clone();
+        get_libfunc_id_with_generic_arg(db, "struct_snapshot_deconstruct", concrete_type)
     } else if is_box {
         let inner_ty = extract_matches!(&long_id.generic_args[0], GenericArg::Type).clone();
         get_libfunc_id_with_generic_arg(db, "struct_boxed_deconstruct", inner_ty)