flow-control: Support let-else.

commit-id:17f9f2da

Author: liorgold2

crates/cairo-lang-lowering/src/lower/flow_control/create_graph.rs

@@ -1,13 +1,14 @@
 use cache::Cache;
-use cairo_lang_semantic::{self as semantic, Condition, PatternId};
+use cairo_lang_semantic::{self as semantic, Condition, ExprId, PatternId};
 use cairo_lang_syntax::node::TypedStablePtr;
+use cairo_lang_syntax::node::ids::SyntaxStablePtrId;
 use filtered_patterns::IndexAndBindings;
 use itertools::Itertools;
 use patterns::{CreateNodeParams, create_node_for_patterns, get_pattern};
 
 use super::graph::{
     ArmExpr, BooleanIf, EvaluateExpr, FlowControlGraph, FlowControlGraphBuilder, FlowControlNode,
-    NodeId,
+    LetElseSuccess, NodeId,
 };
 use crate::diagnostic::{LoweringDiagnosticKind, MatchDiagnostic, MatchError, MatchKind};
 use crate::lower::context::LoweringContext;
@@ -176,3 +177,55 @@ pub fn create_graph_expr_match<'db>(
 
     graph.finalize(root, ctx)
 }
+
+/// Creates a graph node for a let-else statement.
+///
+/// See [crate::lower::lower_let_else::lower_let_else] for more details.
+pub fn create_graph_expr_let_else<'db>(
+    ctx: &mut LoweringContext<'db, '_>,
+    pattern: PatternId,
+    expr_id: ExprId,
+    else_clause: ExprId,
+    var_ids_and_stable_ptrs: Vec<(semantic::VarId<'db>, SyntaxStablePtrId<'db>)>,
+) -> FlowControlGraph<'db> {
+    let mut graph = FlowControlGraphBuilder::new(MatchKind::IfLet);
+
+    // Add the `true` branch (the `if` block).
+    let true_branch =
+        graph.add_node(FlowControlNode::LetElseSuccess(LetElseSuccess { var_ids_and_stable_ptrs }));
+
+    // Add the `false` branch (the `else` block), if exists.
+    let false_branch = graph.add_node(FlowControlNode::ArmExpr(ArmExpr { expr: else_clause }));
+
+    let expr = &ctx.function_body.arenas.exprs[expr_id];
+
+    // Create a variable for the expression.
+    let expr_location = ctx.get_location(expr.stable_ptr().untyped());
+    let expr_var = graph.new_var(expr.ty(), expr_location);
+
+    let match_node_id = create_node_for_patterns(
+        CreateNodeParams {
+            ctx,
+            graph: &mut graph,
+            patterns: &[Some(get_pattern(ctx, pattern))],
+            build_node_callback: &mut |graph, pattern_indices, _path| {
+                if let Some(index_and_bindings) = pattern_indices.first() {
+                    index_and_bindings.wrap_node(graph, true_branch)
+                } else {
+                    false_branch
+                }
+            },
+            location: expr_location,
+        },
+        expr_var,
+    );
+
+    // Create a node for lowering `expr_id` into `expr_var` and continue to the match.
+    let root = graph.add_node(FlowControlNode::EvaluateExpr(EvaluateExpr {
+        expr: expr_id,
+        var_id: expr_var,
+        next: match_node_id,
+    }));
+
+    graph.finalize(root, ctx)
+}

crates/cairo-lang-lowering/src/lower/flow_control/graph.rs

@@ -211,6 +211,15 @@ pub struct Downcast {
     pub out_of_range: NodeId,
 }
 
+/// An arm (final node) that returns a tuple of bound variables for the let-else success arm.
+///
+/// See [crate::lower::lower_let_else::lower_let_else] for more details.
+#[derive(Debug)]
+pub struct LetElseSuccess<'db> {
+    /// The variables to assign the result to.
+    pub var_ids_and_stable_ptrs: Vec<(semantic::VarId<'db>, SyntaxStablePtrId<'db>)>,
+}
+
 /// A node in the flow control graph for a match or if lowering.
 pub enum FlowControlNode<'db> {
     /// Evaluates an expression and assigns the result to a [FlowControlVar].
@@ -233,6 +242,8 @@ pub enum FlowControlNode<'db> {
     Upcast(Upcast),
     /// Downcasts a value to a smaller type.
     Downcast(Downcast),
+    /// An arm (final node) that returns a tuple of bound variables for the let-else success arm.
+    LetElseSuccess(LetElseSuccess<'db>),
     /// An arm (final node) that returns a unit value - `()`.
     UnitResult,
     /// Represents a node that could not be properly constructed due to an error in the code.
@@ -258,6 +269,7 @@ impl<'db> FlowControlNode<'db> {
             FlowControlNode::BindVar(node) => Some(node.input),
             FlowControlNode::Upcast(node) => Some(node.input),
             FlowControlNode::Downcast(node) => Some(node.input),
+            FlowControlNode::LetElseSuccess(..) => None,
             FlowControlNode::UnitResult => None,
             FlowControlNode::Missing(_) => None,
         }
@@ -277,6 +289,7 @@ impl<'db> Debug for FlowControlNode<'db> {
             FlowControlNode::BindVar(node) => node.fmt(f),
             FlowControlNode::Upcast(node) => node.fmt(f),
             FlowControlNode::Downcast(node) => node.fmt(f),
+            FlowControlNode::LetElseSuccess(node) => node.fmt(f),
             FlowControlNode::UnitResult => write!(f, "UnitResult"),
             FlowControlNode::Missing(_) => write!(f, "Missing"),
         }

crates/cairo-lang-lowering/src/lower/flow_control/lower_graph/lower_node.rs

@@ -20,8 +20,9 @@ use crate::lower::context::{LoweredExpr, LoweredExprExternEnum, VarRequest};
 use crate::lower::external::extern_facade_expr;
 use crate::lower::flow_control::graph::{
     ArmExpr, BindVar, BooleanIf, Deconstruct, Downcast, EnumMatch, EqualsLiteral, EvaluateExpr,
-    FlowControlNode, NodeId, Upcast, ValueMatch,
+    FlowControlNode, LetElseSuccess, NodeId, Upcast, ValueMatch,
 };
+use crate::lower::lower_let_else::lower_success_arm_body;
 use crate::lower::{
     generators, lower_expr, lower_expr_literal_to_var_usage, match_extern_arm_ref_args_bind,
     match_extern_variant_arm_input_types,
@@ -57,6 +58,7 @@ pub fn lower_node(ctx: &mut LowerGraphContext<'_, '_, '_>, id: NodeId) -> Maybe<
         FlowControlNode::Deconstruct(node) => lower_deconstruct(ctx, id, node, builder),
         FlowControlNode::Upcast(node) => lower_upcast(ctx, id, node, builder),
         FlowControlNode::Downcast(node) => lower_downcast(ctx, id, node, builder),
+        FlowControlNode::LetElseSuccess(node) => lower_let_else_success(ctx, id, node, builder),
         FlowControlNode::Missing(diag_added) => Err(*diag_added),
     }
 }
@@ -507,3 +509,18 @@ fn lower_downcast<'db>(
     ctx.finalize_with_match(id, builder, match_info);
     Ok(())
 }
+
+/// Lowers a [LetElseSuccess] node.
+fn lower_let_else_success<'db>(
+    ctx: &mut LowerGraphContext<'db, '_, '_>,
+    id: NodeId,
+    node: &LetElseSuccess<'db>,
+    builder: BlockBuilder<'db>,
+) -> Maybe<()> {
+    let sealed_goto_callsite =
+        lower_success_arm_body(ctx.ctx, builder, &node.var_ids_and_stable_ptrs, ctx.location);
+    let (builder, var_usage) = sealed_goto_callsite;
+
+    ctx.finalize_with_arm(id, builder, Ok(LoweredExpr::AtVariable(var_usage)))?;
+    Ok(())
+}

crates/cairo-lang-lowering/src/lower/lower_let_else.rs

@@ -6,11 +6,13 @@ use cairo_lang_syntax::node::ids::SyntaxStablePtrId;
 use cairo_lang_utils::Intern;
 use itertools::zip_eq;
 
-use super::block_builder::{BlockBuilder, SealedBlockBuilder};
-use super::context::{LoweredExpr, LoweringContext, LoweringFlowError, VarRequest};
+use super::block_builder::BlockBuilder;
+use super::context::{LoweringContext, LoweringFlowError, VarRequest};
+use super::flow_control::create_graph::create_graph_expr_let_else;
+use super::flow_control::lower_graph::lower_graph;
 use super::generators;
-use super::lower_match::{MatchArmWrapper, lower_match_arms};
-use crate::diagnostic::MatchKind;
+use crate::VarUsage;
+use crate::ids::LocationId;
 
 /// Lowers a let-else statement.
 ///
@@ -34,35 +36,21 @@ pub fn lower_let_else<'db>(
     builder: &mut BlockBuilder<'db>,
     pattern_id: PatternId,
     expr: ExprId,
-    lowered_expr: LoweredExpr<'db>,
     else_clause: ExprId,
     stable_ptr: &StatementPtr<'db>,
 ) -> Result<(), LoweringFlowError<'db>> {
-    let pattern = ctx.function_body.arenas.patterns[pattern_id].clone();
+    let pattern = &ctx.function_body.arenas.patterns[pattern_id];
     let variables = pattern.variables(&ctx.function_body.arenas.patterns);
 
-    // Create a match expression with two arms.
-    let patterns = &[pattern_id];
+    // Create a list of the variables in the pattern, and their stable pointers.
     let var_ids_and_stable_ptrs = variables
         .iter()
         .map(|pattern_var| (VarId::Local(pattern_var.var.id), pattern_var.stable_ptr.untyped()))
         .collect();
-    let arms = vec![
-        MatchArmWrapper::LetElseSuccess(patterns, var_ids_and_stable_ptrs, stable_ptr.untyped()),
-        MatchArmWrapper::ElseClause(else_clause),
-    ];
 
-    // Lower the match expression.
-    // The result is a tuple with the values of the pattern's variables.
-    let match_lowered = lower_match_arms(
-        ctx,
-        builder,
-        expr,
-        lowered_expr,
-        arms,
-        ctx.get_location(stable_ptr.untyped()),
-        MatchKind::Match,
-    )?;
+    let graph =
+        create_graph_expr_let_else(ctx, pattern_id, expr, else_clause, var_ids_and_stable_ptrs);
+    let lowered_expr = lower_graph(ctx, builder, &graph, ctx.get_location(stable_ptr.untyped()))?;
 
     // Destruct the tuple.
     let reqs = variables
@@ -73,7 +61,7 @@ pub fn lower_let_else<'db>(
         })
         .collect();
     let output_vars = generators::StructDestructure {
-        input: match_lowered.as_var_usage(ctx, builder)?,
+        input: lowered_expr.as_var_usage(ctx, builder)?,
         var_reqs: reqs,
     }
     .add(ctx, &mut builder.statements);
@@ -98,8 +86,8 @@ pub fn lower_success_arm_body<'db>(
     ctx: &mut LoweringContext<'db, '_>,
     mut builder: BlockBuilder<'db>,
     vars: &[(VarId<'db>, SyntaxStablePtrId<'db>)],
-    stable_ptr: &SyntaxStablePtrId<'db>,
-) -> SealedBlockBuilder<'db> {
+    location: LocationId<'db>,
+) -> (BlockBuilder<'db>, VarUsage<'db>) {
     log::trace!("Lowering success arm body");
 
     let inputs: Vec<_> = vars
@@ -119,12 +107,8 @@ pub fn lower_success_arm_body<'db>(
 
     let tys = inputs.iter().map(|var_usage| ctx.variables[var_usage.var_id].ty).collect();
     let tuple_ty = TypeLongId::Tuple(tys).intern(ctx.db);
-    let tuple_var_usage = generators::StructConstruct {
-        inputs,
-        ty: tuple_ty,
-        location: ctx.get_location(*stable_ptr),
-    }
-    .add(ctx, &mut builder.statements);
+    let tuple_var_usage = generators::StructConstruct { inputs, ty: tuple_ty, location }
+        .add(ctx, &mut builder.statements);
 
-    builder.goto_callsite(Some(tuple_var_usage))
+    (builder, tuple_var_usage)
 }

crates/cairo-lang-lowering/src/lower/lower_match.rs

@@ -5,7 +5,7 @@ use cairo_lang_diagnostics::{DiagnosticAdded, Maybe};
 use cairo_lang_filesystem::db::FilesGroup;
 use cairo_lang_filesystem::flag::Flag;
 use cairo_lang_filesystem::ids::{FlagId, FlagLongId};
-use cairo_lang_semantic::{self as semantic, ConcreteEnumId, ConcreteVariant, VarId};
+use cairo_lang_semantic::{self as semantic, ConcreteEnumId, ConcreteVariant};
 use cairo_lang_syntax::node::TypedStablePtr;
 use cairo_lang_syntax::node::ids::SyntaxStablePtrId;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
@@ -25,7 +25,6 @@ use super::context::{
     handle_lowering_flow_error,
 };
 use super::lower_if::{ConditionedExpr, lower_conditioned_expr_and_seal};
-use super::lower_let_else::lower_success_arm_body;
 use super::{
     alloc_empty_block, generators, lower_expr_block, lower_tail_expr,
     lowered_expr_to_block_scope_end, recursively_call_loop_func,
@@ -60,13 +59,6 @@ pub enum MatchArmWrapper<'db, 'a> {
     ElseClause(semantic::ExprId),
     /// Default clause when else clause is not provided (if-let/while-let).
     DefaultClause,
-    /// The success arm of a let-else statement. See [super::lower_let_else::lower_let_else] for
-    /// more details.
-    LetElseSuccess(
-        &'a [PatternId],
-        Vec<(VarId<'db>, SyntaxStablePtrId<'db>)>,
-        SyntaxStablePtrId<'db>,
-    ),
     /// Similar to [Self::Arm], except that the expression is a conditioned expression
     /// (see [ConditionedExpr]).
     ConditionedArm(&'a [PatternId], ConditionedExpr<'db, 'a>),
@@ -82,9 +74,9 @@ impl<'db> MatchArmWrapper<'db, '_> {
     /// Returns the patterns of the match arm.
     pub fn patterns(&self) -> Option<&[PatternId]> {
         match self {
-            MatchArmWrapper::Arm(patterns, _)
-            | MatchArmWrapper::ConditionedArm(patterns, _)
-            | MatchArmWrapper::LetElseSuccess(patterns, _, _) => Some(patterns),
+            MatchArmWrapper::Arm(patterns, _) | MatchArmWrapper::ConditionedArm(patterns, _) => {
+                Some(patterns)
+            }
             MatchArmWrapper::ElseClause(_) | MatchArmWrapper::DefaultClause => None,
         }
     }
@@ -197,9 +189,7 @@ fn get_underscore_pattern_path_and_mark_unreachable<'db>(
 
     for arm in arms.iter().skip(otherwise_variant.arm_index + 1) {
         match arm {
-            MatchArmWrapper::Arm(patterns, _)
-            | MatchArmWrapper::ConditionedArm(patterns, _)
-            | MatchArmWrapper::LetElseSuccess(patterns, _, _) => {
+            MatchArmWrapper::Arm(patterns, _) | MatchArmWrapper::ConditionedArm(patterns, _) => {
                 for pattern in *patterns {
                     let pattern_ptr = ctx.function_body.arenas.patterns[*pattern].stable_ptr();
                     ctx.diagnostics.report(
@@ -1162,8 +1152,7 @@ trait EnumVariantScopeBuilder<'db> {
                     continue;
                 }
                 MatchArmWrapper::Arm(patterns, _)
-                | MatchArmWrapper::ConditionedArm(patterns, _)
-                | MatchArmWrapper::LetElseSuccess(patterns, _, _) => patterns,
+                | MatchArmWrapper::ConditionedArm(patterns, _) => patterns,
             };
             for (pattern_index, pattern) in patterns.iter().copied().enumerate() {
                 let pattern_path = PatternPath { arm_index, pattern_index: Some(pattern_index) };
@@ -1366,15 +1355,6 @@ trait EnumVariantScopeBuilder<'db> {
                             }),
                         );
                     },
-                    MatchArmWrapper::LetElseSuccess(_,_, stable_ptr) => {
-                        ctx.diagnostics.report(
-                            *stable_ptr,
-                            MatchError(MatchError {
-                                kind: builder_context.kind,
-                                error: MatchDiagnostic::UnreachableMatchArm,
-                            }),
-                        );
-                    }
                     MatchArmWrapper::DefaultClause => (),
                 }
             }
@@ -1796,12 +1776,6 @@ fn lower_arm_expr_and_seal<'db>(
             lowered_expr_to_block_scope_end(ctx, subscope, block_expr)
         }
         (MatchArmWrapper::DefaultClause, _) => Ok(subscope.goto_callsite(None)),
-        (MatchArmWrapper::LetElseSuccess(_, vars, stable_ptr), MatchKind::Match) => {
-            Ok(lower_success_arm_body(ctx, subscope, vars, stable_ptr))
-        }
-        (MatchArmWrapper::LetElseSuccess(_, _, _), _) => {
-            unreachable!("Invalid MatchKind for LetElseSuccess.")
-        }
         (MatchArmWrapper::ConditionedArm(_, expr), _) => {
             lower_conditioned_expr_and_seal(ctx, subscope, expr)
         }

crates/cairo-lang-lowering/src/lower/mod.rs

@@ -663,19 +663,19 @@ pub fn lower_statement<'db>(
             else_clause,
             stable_ptr,
         }) => {
-            log::trace!("Lowering a let statement.");
-            let lowered_expr = lower_expr(ctx, builder, *expr)?;
             if let Some(else_clause) = else_clause {
+                log::trace!("Lowering a let-else statement.");
                 lower_let_else::lower_let_else(
                     ctx,
                     builder,
                     *pattern,
                     *expr,
-                    lowered_expr,
                     *else_clause,
                     stable_ptr,
                 )?;
             } else {
+                log::trace!("Lowering a let statement.");
+                let lowered_expr = lower_expr(ctx, builder, *expr)?;
                 lower_single_pattern(ctx, builder, *pattern, lowered_expr, true)?;
             }
         }