diff --git a/crates/cairo-lang-lowering/src/lower/lower_match.rs b/crates/cairo-lang-lowering/src/lower/lower_match.rs index d7416760834..bad8cb73cf8 100644 --- a/crates/cairo-lang-lowering/src/lower/lower_match.rs +++ b/crates/cairo-lang-lowering/src/lower/lower_match.rs @@ -685,10 +685,10 @@ fn lower_tuple_match_arm( inner_pattern: Some(inner_pattern), .. }) => { - let inner_pattern = - ctx.function_body.arenas.patterns[*inner_pattern].clone(); - let pattern_location = - ctx.get_location(inner_pattern.stable_ptr().untyped()); + let inner_pattern = *inner_pattern; + let pattern_location = ctx.get_location( + ctx.function_body.arenas.patterns[inner_pattern].stable_ptr().untyped(), + ); let variant_expr = LoweredExpr::AtVariable(VarUsage { var_id: match_tuple_ctx.current_var_ids[index], @@ -1031,8 +1031,10 @@ pub(crate) fn lower_concrete_enum_match( inner_pattern: Some(inner_pattern), .. })) => { - let inner_pattern = ctx.function_body.arenas.patterns[*inner_pattern].clone(); - let pattern_location = ctx.get_location(inner_pattern.stable_ptr().untyped()); + let inner_pattern = *inner_pattern; + let pattern_location = ctx.get_location( + ctx.function_body.arenas.patterns[inner_pattern].stable_ptr().untyped(), + ); let var_id = ctx.new_var(VarRequest { ty: wrap_in_snapshots(ctx.db, concrete_variant.ty, n_snapshots), @@ -1178,12 +1180,7 @@ pub(crate) fn lower_optimized_extern_match( Some(Pattern::EnumVariant(PatternEnumVariant { inner_pattern: Some(inner_pattern), .. - })) => lower_single_pattern( - ctx, - &mut subscope, - ctx.function_body.arenas.patterns[*inner_pattern].clone(), - variant_expr, - ), + })) => lower_single_pattern(ctx, &mut subscope, *inner_pattern, variant_expr), Some( Pattern::EnumVariant(PatternEnumVariant { inner_pattern: None, .. }) | Pattern::Otherwise(_), diff --git a/crates/cairo-lang-lowering/src/lower/mod.rs b/crates/cairo-lang-lowering/src/lower/mod.rs index d6eff3d988b..e58d2017ea8 100644 --- a/crates/cairo-lang-lowering/src/lower/mod.rs +++ b/crates/cairo-lang-lowering/src/lower/mod.rs @@ -200,7 +200,6 @@ pub fn lower_for_loop( }; let next_value_type = some_variant.ty; builder.update_ref(ctx, &loop_expr.into_iter_member_path, next_iterator.var_id); - let pattern = ctx.function_body.arenas.patterns[loop_expr.pattern].clone(); let unit_ty = corelib::unit_ty(db); let some_block: cairo_lang_semantic::ExprBlock = extract_matches!(&ctx.function_body.arenas.exprs[loop_expr.body], semantic::Expr::Block) @@ -215,7 +214,8 @@ pub fn lower_for_loop( var_id: some_var_id, location: ctx.get_location(some_block.stable_ptr.untyped()), }); - let lowered_pattern = lower_single_pattern(ctx, &mut some_subscope, pattern, variant_expr); + let lowered_pattern = + lower_single_pattern(ctx, &mut some_subscope, loop_expr.pattern, variant_expr); let sealed_some = match lowered_pattern { Ok(_) => { let block_expr = (|| { @@ -651,8 +651,7 @@ pub fn lower_statement( semantic::Statement::Let(semantic::StatementLet { pattern, expr, stable_ptr: _ }) => { log::trace!("Lowering a let statement."); let lowered_expr = lower_expr(ctx, builder, *expr)?; - let pattern = ctx.function_body.arenas.patterns[*pattern].clone(); - lower_single_pattern(ctx, builder, pattern, lowered_expr)? + lower_single_pattern(ctx, builder, *pattern, lowered_expr)? } semantic::Statement::Continue(semantic::StatementContinue { stable_ptr }) => { log::trace!("Lowering a continue statement."); @@ -698,16 +697,17 @@ pub fn lower_statement( fn lower_single_pattern( ctx: &mut LoweringContext<'_, '_>, builder: &mut BlockBuilder, - pattern: semantic::Pattern, + pattern_id: semantic::PatternId, lowered_expr: LoweredExpr, ) -> Result<(), LoweringFlowError> { log::trace!("Lowering a single pattern."); + let pattern = &ctx.function_body.arenas.patterns[pattern_id]; match pattern { semantic::Pattern::Literal(_) | semantic::Pattern::StringLiteral(_) | semantic::Pattern::EnumVariant(_) => { return Err(LoweringFlowError::Failed( - ctx.diagnostics.report(&pattern, UnsupportedPattern), + ctx.diagnostics.report(pattern.stable_ptr(), UnsupportedPattern), )); } semantic::Pattern::Variable(semantic::PatternVariable { @@ -715,7 +715,8 @@ fn lower_single_pattern( var: sem_var, stable_ptr, }) => { - let sem_var = semantic::Binding::LocalVar(sem_var); + let sem_var = semantic::Binding::LocalVar(sem_var.clone()); + let stable_ptr = *stable_ptr; // Deposit the owned variable in the semantic variables store. let var = lowered_expr.as_var_usage(ctx, builder)?.var_id; // Override variable location. @@ -730,23 +731,25 @@ fn lower_single_pattern( .concrete_struct_members(structure.concrete_struct_id) .map_err(LoweringFlowError::Failed)?; let mut required_members = UnorderedHashMap::<_, _>::from_iter( - structure.field_patterns.iter().map(|(member, pattern)| (member.id, pattern)), + structure.field_patterns.iter().map(|(member, pattern)| (member.id, *pattern)), ); + let n_snapshots = structure.n_snapshots; + let stable_ptr = structure.stable_ptr.untyped(); let generator = generators::StructDestructure { input: lowered_expr.as_var_usage(ctx, builder)?, var_reqs: members .iter() .map(|(_, member)| VarRequest { - ty: wrap_in_snapshots(ctx.db, member.ty, structure.n_snapshots), + ty: wrap_in_snapshots(ctx.db, member.ty, n_snapshots), location: ctx.get_location( required_members .get(&member.id) .map(|pattern| { - ctx.function_body.arenas.patterns[**pattern] + ctx.function_body.arenas.patterns[*pattern] .stable_ptr() .untyped() }) - .unwrap_or_else(|| structure.stable_ptr.untyped()), + .unwrap_or_else(|| stable_ptr), ), }) .collect(), @@ -755,8 +758,7 @@ fn lower_single_pattern( izip!(generator.add(ctx, &mut builder.statements), members.iter()) { if let Some(member_pattern) = required_members.remove(&member.id) { - let member_pattern = ctx.function_body.arenas.patterns[*member_pattern].clone(); - let stable_ptr = member_pattern.stable_ptr(); + let stable_ptr = ctx.function_body.arenas.patterns[member_pattern].stable_ptr(); lower_single_pattern( ctx, builder, @@ -777,11 +779,13 @@ fn lower_single_pattern( ty, .. }) => { - lower_tuple_like_pattern_helper(ctx, builder, lowered_expr, &patterns, ty)?; + let patterns = patterns.clone(); + lower_tuple_like_pattern_helper(ctx, builder, lowered_expr, &patterns, *ty)?; } semantic::Pattern::Otherwise(pattern) => { + let stable_ptr = pattern.stable_ptr.untyped(); let var = lowered_expr.as_var_usage(ctx, builder)?.var_id; - ctx.variables.variables[var].location = ctx.get_location(pattern.stable_ptr.untyped()); + ctx.variables.variables[var].location = ctx.get_location(stable_ptr); } semantic::Pattern::Missing(_) => unreachable!("Missing pattern in semantic model."), } @@ -840,12 +844,7 @@ fn lower_tuple_like_pattern_helper( } }; for (var, pattern) in zip_eq(outputs, patterns) { - lower_single_pattern( - ctx, - builder, - ctx.function_body.arenas.patterns[*pattern].clone(), - var, - )?; + lower_single_pattern(ctx, builder, *pattern, var)?; } Ok(()) }