Merge branch 'main' into patch-16

Author: conomist

crates/cairo-lang-sierra-ap-change/src/core_libfunc_ap_change.rs

@@ -15,7 +15,7 @@ use cairo_lang_sierra::extensions::const_type::ConstConcreteLibfunc;
 use cairo_lang_sierra::extensions::core::CoreConcreteLibfunc::{self, *};
 use cairo_lang_sierra::extensions::coupon::CouponConcreteLibfunc;
 use cairo_lang_sierra::extensions::ec::EcConcreteLibfunc;
-use cairo_lang_sierra::extensions::enm::EnumConcreteLibfunc;
+use cairo_lang_sierra::extensions::enm::{EnumBoxedMatchConcreteLibfunc, EnumConcreteLibfunc};
 use cairo_lang_sierra::extensions::felt252::{
     Felt252BinaryOperationConcrete, Felt252BinaryOperator, Felt252Concrete,
 };
@@ -32,6 +32,7 @@ use cairo_lang_sierra::extensions::int::unsigned256::Uint256Concrete;
 use cairo_lang_sierra::extensions::int::unsigned512::Uint512Concrete;
 use cairo_lang_sierra::extensions::int::{IntMulTraits, IntOperator};
 use cairo_lang_sierra::extensions::is_zero::IsZeroTraits;
+use cairo_lang_sierra::extensions::lib_func::SignatureOnlyConcreteLibfunc;
 use cairo_lang_sierra::extensions::mem::MemConcreteLibfunc;
 use cairo_lang_sierra::extensions::nullable::NullableConcreteLibfunc;
 use cairo_lang_sierra::extensions::pedersen::PedersenConcreteLibfunc;
@@ -293,8 +294,19 @@ pub fn core_libfunc_ap_change<InfoProvider: InvocationApChangeInfoProvider>(
                 1 | 2 => vec![ApChange::Known(0)],
                 _ => vec![ApChange::Known(1)],
             },
-            EnumConcreteLibfunc::Match(libfunc) | EnumConcreteLibfunc::SnapshotMatch(libfunc) => {
-                vec![ApChange::Known(0); libfunc.signature.branch_signatures.len()]
+            EnumConcreteLibfunc::Match(SignatureOnlyConcreteLibfunc { signature, .. })
+            | EnumConcreteLibfunc::SnapshotMatch(SignatureOnlyConcreteLibfunc {
+                signature, ..
+            }) => {
+                vec![ApChange::Known(0); signature.branch_signatures.len()]
+            }
+            EnumConcreteLibfunc::BoxedMatch(EnumBoxedMatchConcreteLibfunc {
+                signature, ..
+            }) => {
+                // For zero or one variants, no instructions are generated (no branching needed)
+                // For other cases, we need 1 AP change for loading the variant selector
+                let n = signature.branch_signatures.len();
+                if n <= 1 { vec![ApChange::Known(0); n] } else { vec![ApChange::Known(1); n] }
             }
         },
         Struct(libfunc) => match libfunc {

crates/cairo-lang-sierra-gas/src/core_libfunc_cost_base.rs

@@ -16,7 +16,7 @@ use cairo_lang_sierra::extensions::const_type::ConstConcreteLibfunc;
 use cairo_lang_sierra::extensions::core::CoreConcreteLibfunc::{self, *};
 use cairo_lang_sierra::extensions::coupon::CouponConcreteLibfunc;
 use cairo_lang_sierra::extensions::ec::EcConcreteLibfunc;
-use cairo_lang_sierra::extensions::enm::EnumConcreteLibfunc;
+use cairo_lang_sierra::extensions::enm::{EnumBoxedMatchConcreteLibfunc, EnumConcreteLibfunc};
 use cairo_lang_sierra::extensions::felt252::{
     Felt252BinaryOperationConcrete, Felt252BinaryOperator, Felt252Concrete,
 };
@@ -411,6 +411,24 @@ pub fn core_libfunc_cost(
                     .collect_vec(),
                 }
             }
+            EnumConcreteLibfunc::BoxedMatch(EnumBoxedMatchConcreteLibfunc {
+                signature, ..
+            }) => {
+                // BoxedMatch needs to load the variant selector with a double-deref (1 step)
+                // plus the regular match cost - but only when branching is actually needed
+                let n = signature.branch_signatures.len();
+                match n {
+                    0 => vec![],
+                    1 => vec![ConstCost::default().into()], // No branching needed for single
+                    // variant
+                    2 => vec![ConstCost::steps(2).into(); 2],
+                    _ => chain!(
+                        iter::once(ConstCost::steps(2).into()),
+                        itertools::repeat_n(ConstCost::steps(3).into(), n - 1)
+                    )
+                    .collect_vec(),
+                }
+            }
         },
         Struct(
             StructConcreteLibfunc::Construct(_)

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

@@ -253,16 +253,24 @@ fn const_type_id(
     ))
 }
 
+/// Returns the appropriate libfunc ID for matching on an enum type.
+///
+/// Selects between `enum_match`, `enum_snapshot_match`, or `enum_boxed_match` based on
+/// whether the type is a snapshot or a boxed type.
 pub fn match_enum_libfunc_id(
     db: &dyn Database,
     ty: cairo_lang_sierra::ids::ConcreteTypeId,
 ) -> Maybe<cairo_lang_sierra::ids::ConcreteLibfuncId> {
     let long_id = &db.get_type_info(ty.clone())?.long_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, "enum_snapshot_match", concrete_enum_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, "enum_boxed_match", inner_ty)
     } else {
         get_libfunc_id_with_generic_arg(db, "enum_match", ty)
     })

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

@@ -1,9 +1,15 @@
+use std::iter;
+
+use cairo_lang_casm::ap_change::ApplyApChange;
 use cairo_lang_casm::builder::CasmBuilder;
-use cairo_lang_casm::cell_expression::CellExpression;
-use cairo_lang_casm::operand::CellRef;
+use cairo_lang_casm::cell_expression::{CellExpression, CellOperator};
+use cairo_lang_casm::instructions::Instruction;
+use cairo_lang_casm::operand::{CellRef, DerefOrImmediate, Register};
 use cairo_lang_casm::{casm, casm_build_extend, casm_extend};
 use cairo_lang_sierra::extensions::ConcreteLibfunc;
-use cairo_lang_sierra::extensions::enm::{EnumConcreteLibfunc, EnumInitConcreteLibfunc};
+use cairo_lang_sierra::extensions::enm::{
+    EnumBoxedMatchConcreteLibfunc, EnumConcreteLibfunc, EnumInitConcreteLibfunc,
+};
 use cairo_lang_sierra::ids::ConcreteTypeId;
 use cairo_lang_sierra::program::{BranchInfo, BranchTarget};
 use cairo_lang_utils::try_extract_matches;
@@ -33,6 +39,7 @@ pub fn build(
         EnumConcreteLibfunc::Match(_) | EnumConcreteLibfunc::SnapshotMatch(_) => {
             build_enum_match(builder)
         }
+        EnumConcreteLibfunc::BoxedMatch(libfunc) => build_enum_boxed_match(libfunc, builder),
     }
 }
 
@@ -230,8 +237,20 @@ fn build_enum_match_short(
         Item = impl ExactSizeIterator<Item = ReferenceExpression>,
     >,
 ) -> Result<CompiledInvocation, InvocationError> {
-    let mut instructions = Vec::new();
+    build_enum_match_short_ex(builder, variant_selector, output_expressions, Vec::with_capacity(1))
+}
+
+/// Extended version of `build_enum_match_short` that allows prepending instructions.
+fn build_enum_match_short_ex(
+    builder: CompiledInvocationBuilder<'_>,
+    variant_selector: CellRef,
+    output_expressions: impl ExactSizeIterator<
+        Item = impl ExactSizeIterator<Item = ReferenceExpression>,
+    >,
+    mut instructions: Vec<Instruction>,
+) -> Result<CompiledInvocation, InvocationError> {
     let mut relocations = Vec::new();
+    let base_instruction_count = instructions.len();
 
     // First branch is fallthrough. If there is only one branch, this `match` statement is
     // translated to nothing in Casm.
@@ -245,7 +264,7 @@ fn build_enum_match_short(
 
         instructions.extend(casm! { jmp rel 0 if variant_selector != 0; }.instructions);
         relocations.push(RelocationEntry {
-            instruction_idx: 0,
+            instruction_idx: base_instruction_count,
             relocation: Relocation::RelativeStatementId(statement_id),
         });
     }
@@ -284,12 +303,32 @@ fn build_enum_match_long(
     output_expressions: impl ExactSizeIterator<
         Item = impl ExactSizeIterator<Item = ReferenceExpression>,
     >,
+) -> Result<CompiledInvocation, InvocationError> {
+    let expected_instruction_count = builder.invocation.branches.len() + 1;
+    build_enum_match_long_ex(
+        builder,
+        variant_selector,
+        output_expressions,
+        Vec::with_capacity(expected_instruction_count),
+    )
+}
+
+/// Extended version of `build_enum_match_long` that allows prepending instructions.
+fn build_enum_match_long_ex(
+    builder: CompiledInvocationBuilder<'_>,
+    variant_selector: CellRef,
+    output_expressions: impl ExactSizeIterator<
+        Item = impl ExactSizeIterator<Item = ReferenceExpression>,
+    >,
+    mut instructions: Vec<Instruction>,
 ) -> Result<CompiledInvocation, InvocationError> {
     let target_statement_ids = builder.invocation.branches[1..].iter().map(|b| match b {
         BranchInfo { target: BranchTarget::Statement(stmnt_id), .. } => *stmnt_id,
         _ => panic!("malformed invocation"),
     });
 
+    let base_instruction_count = instructions.len();
+
     // The first instruction is the jmp to the relevant index in the jmp table.
     let mut ctx = casm! { jmp rel variant_selector; };
     let mut relocations = Vec::new();
@@ -300,12 +339,13 @@ fn build_enum_match_long(
         // Add the jump instruction to the relevant target.
         casm_extend!(ctx, jmp rel 0;);
         relocations.push(RelocationEntry {
-            instruction_idx: i + 1,
+            instruction_idx: base_instruction_count + i + 1,
             relocation: Relocation::RelativeStatementId(stmnt_id),
         });
     }
 
-    Ok(builder.build(ctx.instructions, relocations, output_expressions))
+    instructions.extend(ctx.instructions);
+    Ok(builder.build(instructions, relocations, output_expressions))
 }
 
 /// A struct representing an actual enum value in the Sierra program.
@@ -363,3 +403,89 @@ fn get_enum_size(
 ) -> Option<i16> {
     Some(program_info.type_sizes.get(concrete_enum_type)?.to_owned())
 }
+
+/// Generates CASM instructions for matching a boxed enum into individual boxed variants.
+///
+/// This function takes a boxed enum (stored in a single memory cell containing the address)
+/// and branches based on the variant selector, returning a box pointing to the appropriate variant.
+fn build_enum_boxed_match(
+    libfunc: &EnumBoxedMatchConcreteLibfunc,
+    builder: CompiledInvocationBuilder<'_>,
+) -> Result<CompiledInvocation, InvocationError> {
+    let num_branches = builder.invocation.branches.len();
+
+    // Handle zero variants case - no instructions needed for uninhabited type
+    if num_branches == 0 {
+        return Ok(builder.build(
+            vec![],
+            vec![],
+            iter::empty::<iter::Empty<ReferenceExpression>>(),
+        ));
+    }
+
+    let [cell] = builder.try_get_single_cells()?;
+    let cell_ref = cell.to_deref().ok_or(InvocationError::InvalidReferenceExpressionForArgument)?;
+
+    // Calculate the size of each variant
+    let mut variant_sizes: Vec<i16> = Vec::new();
+    for variant_ty in &libfunc.variants {
+        let variant_size = *builder
+            .program_info
+            .type_sizes
+            .get(variant_ty)
+            .ok_or(InvocationError::InvalidReferenceExpressionForArgument)?;
+        variant_sizes.push(variant_size);
+    }
+
+    // The enum size is 1 (selector) + max(variant_sizes)
+    let max_variant_size = variant_sizes.iter().max().copied().unwrap_or(0);
+
+    let output_cellref = if num_branches > 1 {
+        let mut adjusted = cell_ref;
+        assert!(adjusted.apply_known_ap_change(1));
+        adjusted
+    } else {
+        cell_ref
+    };
+
+    // For each branch, we need to create a reference to Box<Variant>
+    // The variant data starts at offset 1 + padding to skip to the variant
+    let output_expressions_for_branches = variant_sizes.iter().map(|&variant_size| {
+        // Calculate padding: the variant is right-aligned in the enum's value space
+        let padding = max_variant_size - variant_size;
+        // The box should point to: base_addr + 1 (selector) + padding
+        let variant_offset = 1 + padding;
+        let variant_box = CellExpression::BinOp {
+            op: CellOperator::Add,
+            a: output_cellref,
+            b: DerefOrImmediate::Immediate(variant_offset.into()),
+        };
+
+        vec![ReferenceExpression::from_cell(variant_box)].into_iter()
+    });
+
+    // For single variant enums, no branching is needed - just return the variant box
+    if num_branches == 1 {
+        return Ok(builder.build(vec![], vec![], output_expressions_for_branches));
+    }
+
+    // Load the variant selector into a temporary - this is a double deref
+    let instructions = casm! { [ap] = [[&cell_ref]], ap++; }.instructions;
+    let variant_selector_cell = CellRef { register: Register::AP, offset: -1 };
+
+    if num_branches == 2 {
+        build_enum_match_short_ex(
+            builder,
+            variant_selector_cell,
+            output_expressions_for_branches.into_iter().map(|v| v.into_iter()),
+            instructions,
+        )
+    } else {
+        build_enum_match_long_ex(
+            builder,
+            variant_selector_cell,
+            output_expressions_for_branches.into_iter().map(|v| v.into_iter()),
+            instructions,
+        )
+    }
+}