flow-control: More cleanup. (#8434)

Author: liorgold2

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

@@ -1,5 +1,8 @@
 use cairo_lang_defs::ids::NamedLanguageElementId;
 use cairo_lang_diagnostics::Maybe;
+use cairo_lang_filesystem::db::FilesGroup;
+use cairo_lang_filesystem::flag::Flag;
+use cairo_lang_filesystem::ids::{FlagId, FlagLongId};
 use cairo_lang_semantic::corelib::{CorelibSemantic, validate_literal};
 use cairo_lang_semantic::items::enm::SemanticEnumEx;
 use cairo_lang_semantic::items::structure::StructSemantic;
@@ -24,7 +27,6 @@ use crate::diagnostic::{LoweringDiagnosticKind, MatchDiagnostic, MatchError};
 use crate::ids::LocationId;
 use crate::lower::context::LoweringContext;
 use crate::lower::flow_control::graph::{Downcast, EqualsLiteral, Upcast, ValueMatch};
-use crate::lower::lower_match::numeric_match_optimization_threshold;
 
 /// A callback that gets a [FilteredPatterns] and constructs a node that continues the pattern
 /// matching restricted to the filtered patterns.
@@ -667,6 +669,29 @@ fn optimized_value_match_size<'db>(
     if n_arms >= numeric_match_optimization_threshold(ctx, is_small_type) { i } else { 0 }
 }
 
+/// Returns the threshold for the number of arms for optimizing numeric match expressions, by using
+/// a jump table instead of an if-else construct.
+/// `is_small_type` means the matched type has < 2**128 possible values.
+pub fn numeric_match_optimization_threshold<'db>(
+    ctx: &LoweringContext<'db, '_>,
+    is_small_type: bool,
+) -> usize {
+    // For felt252 the number of steps with if-else is 2 * min(n, number_of_arms) + 2 and 11~13 for
+    // jump table for small_types the number of steps with if-else is 2 * min(n, number_of_arms) + 4
+    // and 9~12 for jump table.
+    let default_threshold = if is_small_type { 8 } else { 10 };
+    ctx.db
+        .get_flag(FlagId::new(
+            ctx.db,
+            FlagLongId("numeric_match_optimization_min_arms_threshold".into()),
+        ))
+        .map(|flag| match *flag {
+            Flag::NumericMatchOptimizationMinArmsThreshold(threshold) => threshold,
+            _ => panic!("Wrong type flag `{flag:?}`."),
+        })
+        .unwrap_or(default_threshold)
+}
+
 /// Returns `true` if the pattern accepts any value (`_` or a variable name).
 fn pattern_is_any<'a, 'db>(pattern: &'a semantic::Pattern<'db>) -> bool {
     match pattern {

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

@@ -25,7 +25,9 @@ use cairo_lang_utils::unordered_hash_map::{Entry, UnorderedHashMap};
 use cairo_lang_utils::{Intern, extract_matches, try_extract_matches};
 use context::handle_lowering_flow_error;
 use defs::ids::TopLevelLanguageElementId;
-use flow_control::create_graph::create_graph_expr_while_let;
+use flow_control::create_graph::{
+    create_graph_expr_if, create_graph_expr_match, create_graph_expr_while_let,
+};
 use flow_control::lower_graph::lower_graph;
 use itertools::{Itertools, chain, izip, zip_eq};
 use num_bigint::{BigInt, Sign};
@@ -50,8 +52,6 @@ use self::context::{
 };
 use self::external::{extern_facade_expr, extern_facade_return_tys};
 use self::logical_op::lower_logical_op;
-use self::lower_if::lower_expr_if;
-use self::lower_match::lower_expr_match;
 use crate::blocks::Blocks;
 use crate::diagnostic::LoweringDiagnosticKind::{self, *};
 use crate::diagnostic::LoweringDiagnosticsBuilder;
@@ -71,9 +71,7 @@ mod external;
 mod flow_control;
 pub mod generators;
 mod logical_op;
-mod lower_if;
 mod lower_let_else;
-mod lower_match;
 pub mod refs;
 
 #[cfg(test)]
@@ -1204,6 +1202,27 @@ fn lower_expr_desnap<'db>(
     ))
 }
 
+/// Lowers an expression of type [semantic::ExprIf].
+fn lower_expr_if<'db>(
+    ctx: &mut LoweringContext<'db, '_>,
+    builder: &mut BlockBuilder<'db>,
+    expr: &semantic::ExprIf<'db>,
+) -> LoweringResult<'db, LoweredExpr<'db>> {
+    let graph = create_graph_expr_if(ctx, expr);
+    lower_graph(ctx, builder, &graph, ctx.get_location(expr.stable_ptr.untyped()))
+}
+
+/// Lowers an expression of type [semantic::ExprMatch].
+fn lower_expr_match<'db>(
+    ctx: &mut LoweringContext<'db, '_>,
+    expr: &semantic::ExprMatch<'db>,
+    builder: &mut BlockBuilder<'db>,
+) -> LoweringResult<'db, LoweredExpr<'db>> {
+    log::trace!("Lowering a match expression: {:?}", expr.debug(&ctx.expr_formatter));
+    let graph = create_graph_expr_match(ctx, expr);
+    lower_graph(ctx, builder, &graph, ctx.get_location(expr.stable_ptr.untyped()))
+}
+
 /// Lowers an expression of type [semantic::ExprFunctionCall].
 fn lower_expr_function_call<'db>(
     ctx: &mut LoweringContext<'db, '_>,