flow-control: Add an example for an uncovered pattern. (#8370)

liorgold2 · web-flow · commit 83539333e0d5 · 2025-09-12T17:25:11.000Z
diff --git a/crates/cairo-lang-lowering/src/lower/flow_control/create_graph.rs b/crates/cairo-lang-lowering/src/lower/flow_control/create_graph.rs
@@ -75,14 +75,15 @@ pub fn create_graph_expr_if<'db>(
                             .iter()
                             .map(|pattern| Some(get_pattern(ctx, *pattern)))
                             .collect_vec(),
-                        build_node_callback: &mut |graph, pattern_indices| {
+                        build_node_callback: &mut |graph, pattern_indices, path| {
                             if let Some(index_and_bindings) = pattern_indices.first() {
                                 cache.get_or_compute(
-                                    &mut |graph, index_and_bindings: IndexAndBindings| {
+                                    &mut |graph, index_and_bindings: IndexAndBindings, _path| {
                                         index_and_bindings.wrap_node(graph, current_node)
                                     },
                                     graph,
                                     index_and_bindings,
+                                    path,
                                 )
                             } else {
                                 false_branch
@@ -141,24 +142,25 @@ pub fn create_graph_expr_match<'db>(
                 .iter()
                 .map(|(pattern, _)| Some(get_pattern(ctx, *pattern)))
                 .collect_vec(),
-            build_node_callback: &mut |graph, pattern_indices| {
+            build_node_callback: &mut |graph, pattern_indices, path| {
                 // Get the first arm that matches.
                 let Some(index_and_bindings) = pattern_indices.first() else {
                     // If no arm is available, report a non-exhaustive match error.
                     let kind = LoweringDiagnosticKind::MatchError(MatchError {
                         kind: MatchKind::Match,
-                        error: MatchDiagnostic::NonExhaustiveMatchValue,
+                        error: MatchDiagnostic::MissingMatchArm(path),
                     });
                     return graph.report_with_missing_node(expr.stable_ptr.untyped(), kind);
                 };
 
                 cache.get_or_compute(
-                    &mut |graph, index_and_bindings: IndexAndBindings| {
+                    &mut |graph, index_and_bindings: IndexAndBindings, _path| {
                         let index = index_and_bindings.index();
                         index_and_bindings.wrap_node(graph, pattern_and_nodes[index].1)
                     },
                     graph,
                     index_and_bindings,
+                    path,
                 )
             },
             location: matched_expr_location,
diff --git a/crates/cairo-lang-lowering/src/lower/flow_control/create_graph/cache.rs b/crates/cairo-lang-lowering/src/lower/flow_control/create_graph/cache.rs
@@ -15,15 +15,16 @@ impl<Input: std::hash::Hash + Eq + Clone> Cache<Input> {
     /// Returns the previous result, otherwise.
     pub fn get_or_compute<'db>(
         &mut self,
-        callback: &mut dyn FnMut(&mut FlowControlGraphBuilder<'db>, Input) -> NodeId,
+        callback: &mut dyn FnMut(&mut FlowControlGraphBuilder<'db>, Input, String) -> NodeId,
         graph: &mut FlowControlGraphBuilder<'db>,
         input: Input,
+        path: String,
     ) -> NodeId {
         if let Some(node_id) = self.cache.get(&input) {
             return *node_id;
         }
 
-        let node_id = callback(graph, input.clone());
+        let node_id = callback(graph, input.clone(), path);
         assert!(!self.cache.contains_key(&input));
         self.cache.insert(input, node_id);
         node_id
diff --git a/crates/cairo-lang-lowering/src/lower/flow_control/create_graph/patterns.rs b/crates/cairo-lang-lowering/src/lower/flow_control/create_graph/patterns.rs
@@ -1,3 +1,4 @@
+use cairo_lang_defs::ids::NamedLanguageElementId;
 use cairo_lang_diagnostics::Maybe;
 use cairo_lang_semantic::corelib::validate_literal;
 use cairo_lang_semantic::db::SemanticGroup;
@@ -13,6 +14,7 @@ use cairo_lang_utils::iterators::zip_eq3;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use itertools::Itertools;
 use num_bigint::BigInt;
+use salsa::Database;
 
 use super::super::graph::{
     Deconstruct, EnumMatch, FlowControlGraphBuilder, FlowControlNode, FlowControlVar, NodeId,
@@ -48,8 +50,10 @@ use crate::lower::lower_match::numeric_match_optimization_threshold;
 /// returns `0` if `y=C` and `1` otherwise.
 /// Finally, the inner pattern-matching function (for `x`) will construct a [EnumMatch] node
 /// that leads to the two nodes returned by the callback.
+///
+/// The `path: String` parameter is an example for a pattern leading to this callback.
 type BuildNodeCallback<'db, 'a> =
-    &'a mut dyn FnMut(&mut FlowControlGraphBuilder<'db>, FilteredPatterns) -> NodeId;
+    &'a mut dyn FnMut(&mut FlowControlGraphBuilder<'db>, FilteredPatterns, String) -> NodeId;
 
 /// A thin wrapper around [semantic::Pattern], where `None` represents the `_` pattern.
 type PatternOption<'a, 'db> = Option<&'a semantic::Pattern<'db>>;
@@ -95,14 +99,16 @@ pub fn create_node_for_patterns<'db>(
     let mut cache = Cache::default();
 
     // Wrap `build_node_callback` to add the bindings to the patterns and cache the result.
-    let mut build_node_callback =
-        |graph: &mut FlowControlGraphBuilder<'db>, pattern_indices: FilteredPatterns| {
-            cache.get_or_compute(
-                build_node_callback,
-                graph,
-                pattern_indices.add_bindings(bindings.clone()),
-            )
-        };
+    let mut build_node_callback = |graph: &mut FlowControlGraphBuilder<'db>,
+                                   pattern_indices: FilteredPatterns,
+                                   path: String| {
+        cache.get_or_compute(
+            build_node_callback,
+            graph,
+            pattern_indices.add_bindings(bindings.clone()),
+            path,
+        )
+    };
 
     let var_ty = graph.var_ty(input_var);
     let (n_snapshots, long_ty) = peel_snapshots(ctx.db, var_ty);
@@ -130,7 +136,7 @@ pub fn create_node_for_patterns<'db>(
     else {
         // If all the patterns are catch-all, we do not need to look into `input_var`.
         // Call the callback with all patterns accepted.
-        return build_node_callback(graph, FilteredPatterns::all(patterns.len()));
+        return build_node_callback(graph, FilteredPatterns::all(patterns.len()), "_".into());
     };
 
     // Check if this is a numeric type that should use value matching.
@@ -225,8 +231,12 @@ fn create_node_for_enum<'db>(
                         ctx,
                         graph,
                         patterns: &inner_patterns,
-                        build_node_callback: &mut |graph, pattern_indices_inner| {
-                            build_node_callback(graph, pattern_indices_inner.lift(&pattern_indices))
+                        build_node_callback: &mut |graph, pattern_indices_inner, path| {
+                            build_node_callback(
+                                graph,
+                                pattern_indices_inner.lift(&pattern_indices),
+                                format!("{}({path})", concrete_variant.id.name(ctx.db)),
+                            )
                         },
                         location,
                     },
@@ -269,7 +279,15 @@ fn create_node_for_tuple<'db>(
         .collect_vec();
 
     let node = create_node_for_tuple_inner(
-        CreateNodeParams { ctx, graph, patterns, build_node_callback, location },
+        CreateNodeParams {
+            ctx,
+            graph,
+            patterns,
+            build_node_callback: &mut |graph, pattern_indices, path| {
+                build_node_callback(graph, pattern_indices, format!("({path})"))
+            },
+            location,
+        },
         &inner_vars,
         types,
         0,
@@ -305,7 +323,16 @@ fn create_node_for_struct<'db>(
         .collect_vec();
 
     let node = create_node_for_tuple_inner(
-        CreateNodeParams { ctx, graph, patterns, build_node_callback, location },
+        CreateNodeParams {
+            ctx,
+            graph,
+            patterns,
+            build_node_callback: &mut |graph, pattern_indices, path| {
+                let struct_name = concrete_struct_id.struct_id(ctx.db).name(ctx.db);
+                build_node_callback(graph, pattern_indices, format!("{struct_name}{{{path}}}"))
+            },
+            location,
+        },
         &inner_vars,
         &types,
         0,
@@ -334,7 +361,7 @@ fn create_node_for_tuple_inner<'db>(
     let CreateNodeParams { ctx, graph, patterns, build_node_callback, location } = params;
 
     if item_idx == types.len() {
-        return build_node_callback(graph, FilteredPatterns::all(patterns.len()));
+        return build_node_callback(graph, FilteredPatterns::all(patterns.len()), "".into());
     }
 
     // If the type is a struct, get the current member.
@@ -399,15 +426,19 @@ fn create_node_for_tuple_inner<'db>(
             ctx,
             graph,
             patterns: &patterns_ref,
-            build_node_callback: &mut |graph, pattern_indices| {
+            build_node_callback: &mut |graph, pattern_indices, path_head| {
                 // Call `create_node_for_tuple_inner` recursively to handle the rest of the tuple.
                 create_node_for_tuple_inner(
                     CreateNodeParams {
                         ctx,
                         graph,
                         patterns: &pattern_indices.indices().map(|idx| patterns[idx]).collect_vec(),
-                        build_node_callback: &mut |graph, pattern_indices_inner| {
-                            build_node_callback(graph, pattern_indices_inner.lift(&pattern_indices))
+                        build_node_callback: &mut |graph, pattern_indices_inner, path_tail| {
+                            build_node_callback(
+                                graph,
+                                pattern_indices_inner.lift(&pattern_indices),
+                                add_item_to_path(ctx.db, &path_head, &path_tail, current_member),
+                            )
                         },
                         location,
                     },
@@ -423,6 +454,34 @@ fn create_node_for_tuple_inner<'db>(
     )
 }
 
+/// Concatenates the given `item` to the given `path_tail`.
+///
+///  Adds the member name if the current item is a struct, and adds a comma if necessary.
+///
+/// `current_member` is `None` for tuples, and `Some` for structs.
+///
+/// For example, for tuples (`current_member` is `None`):
+///   if `item` is `A` and `path_tail` is `B, C`, the result is `A, B, C`.
+/// For structs (`current_member` is `Some`):
+///   if `item` is `A` and `path_tail` is `b: B, c: C`, the result will be of the form:
+///   `a: A, b: B, c: C`.
+fn add_item_to_path<'db>(
+    db: &dyn Database,
+    item: &String,
+    path_tail: &String,
+    current_member: Option<&semantic::Member<'db>>,
+) -> String {
+    // If it's a struct, add the member name.
+    let item_str = if let Some(current_member) = current_member {
+        format!("{}: {}", current_member.id.name(db), item)
+    } else {
+        item.clone()
+    };
+
+    // If it's not the only item, add a comma.
+    if path_tail.is_empty() { item_str } else { format!("{item_str}, {path_tail}") }
+}
+
 /// Handles the u256 literal as if it was a pattern of the form `u256 { low: ..., high: ... }`.
 ///
 /// According to `item_idx`, returns the low or the high part of the value as a u128 literal
@@ -528,7 +587,7 @@ fn create_node_for_value<'db>(
     };
 
     // First, construct a node that handles the otherwise patterns.
-    let mut current_node = build_node_callback(graph, otherwise_filter.clone());
+    let mut current_node = build_node_callback(graph, otherwise_filter.clone(), "_".into());
 
     // Go over the literals (in reverse order), and construct a chain of [BooleanIf] nodes that
     // handle each literal.
@@ -537,7 +596,7 @@ fn create_node_for_value<'db>(
         if *literal < value_match_size_bigint {
             continue;
         }
-        let node_if_literal = build_node_callback(graph, filter.clone());
+        let node_if_literal = build_node_callback(graph, filter.clone(), literal.to_string());
 
         // Don't add an [EqualsLiteral] node if both branches lead to the same node.
         if node_if_literal == current_node {
@@ -567,7 +626,9 @@ fn create_node_for_value<'db>(
         let in_range_var = graph.new_var(bounded_int_ty, graph.var_location(input_var));
 
         let nodes = (0..value_match_size)
-            .map(|i| build_node_callback(graph, literals_map[&BigInt::from(i)].0.clone()))
+            .map(|i| {
+                build_node_callback(graph, literals_map[&BigInt::from(i)].0.clone(), i.to_string())
+            })
             .collect();
         let value_match_node = graph
             .add_node(FlowControlNode::ValueMatch(ValueMatch { matched_var: in_range_var, nodes }));
diff --git a/crates/cairo-lang-lowering/src/lower/flow_control/test_data/match b/crates/cairo-lang-lowering/src/lower/flow_control/test_data/match
@@ -1384,35 +1384,45 @@ End:
 test_create_graph(expect_diagnostics: true)
 
 //! > function_code
-fn foo(x: Option<Option<felt252>>) -> felt252 {
+fn foo(x: MyStruct) -> felt252 {
     match x {
-        Some(Some(_)) => 1,
-        None => 2,
+        MyStruct { a: Some(Some(_)), .. } => 1,
+        MyStruct { b: (None, _, _), .. } => 1,
     }
 }
 
+//! > module_code
+struct MyStruct {
+    a: Option<Option<felt252>>,
+    b: (Option<felt252>, felt252, felt252),
+}
+
 //! > graph
-Root: 5
-5 EvaluateExpr { expr: ExprId(0), var_id: v0, next: NodeId(4) }
-4 EnumMatch { matched_var: v0, variants: (NodeId(3), v1), (NodeId(1), v4)}
-3 EnumMatch { matched_var: v1, variants: (NodeId(0), v2), (NodeId(2), v3)}
-2 Missing
+Root: 9
+9 EvaluateExpr { expr: ExprId(0), var_id: v0, next: NodeId(8) }
+8 Deconstruct { input: v0, outputs: [v1, v2], next: NodeId(7) }
+7 EnumMatch { matched_var: v1, variants: (NodeId(6), v3), (NodeId(5), v16)}
+6 EnumMatch { matched_var: v3, variants: (NodeId(2), v4), (NodeId(5), v10)}
+5 Deconstruct { input: v2, outputs: [v11, v12, v13], next: NodeId(4) }
+4 EnumMatch { matched_var: v11, variants: (NodeId(3), v14), (NodeId(1), v15)}
+3 Missing
+2 Deconstruct { input: v2, outputs: [v5, v6, v7], next: NodeId(0) }
 1 ArmExpr { expr: ExprId(2) }
 0 ArmExpr { expr: ExprId(1) }
 
 //! > semantic_diagnostics
 
 //! > lowering_diagnostics
-error: Match is non exhaustive - add a wildcard pattern (`_`).
- --> lib.cairo:2:5-5:5
+error: Missing match arm: `MyStruct{a: Some(None(_)), b: (Some(_), _, _)}` not covered.
+ --> lib.cairo:6:5-9:5
       match x {
  _____^
 | ...
 |     }
 |_____^
 
 //! > lowered
-Parameters: v0: core::option::Option::<core::option::Option::<core::felt252>>
+Parameters: v0: test::MyStruct
 
 //! > ==========================================================================
 
@@ -1532,7 +1542,7 @@ Root: 1
 //! > semantic_diagnostics
 
 //! > lowering_diagnostics
-error: Match is non exhaustive - add a wildcard pattern (`_`).
+error: Missing match arm: `_` not covered.
  --> lib.cairo:2:5
     match x {}
     ^^^^^^^^^^
@@ -1594,7 +1604,7 @@ Root: 1
 //! > semantic_diagnostics
 
 //! > lowering_diagnostics
-error: Match is non exhaustive - add a wildcard pattern (`_`).
+error: Missing match arm: `_` not covered.
  --> lib.cairo:5:5
     match x {}
     ^^^^^^^^^^
