Code Cleanup in lowering matching code (#7715)

Author: eytan-starkware

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(_),

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,24 +697,26 @@ 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 {
             name: _,
             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(())
 }