Cherry picks (#8009)

orizi · web-flow · commit 3b2312635ce7 · 2025-07-21T12:31:09.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/corelib/src/byte_array.cairo b/corelib/src/byte_array.cairo
@@ -114,10 +114,9 @@ pub impl ByteArrayImpl of ByteArrayTrait {
 
         // The split index is the number of bytes left for the next word (new pending_word of the
         // modified ByteArray).
-        let split_index = if let Some(split_index) =
-            crate::num::traits::CheckedSub::checked_sub(total_pending_bytes, BYTES_IN_BYTES31) {
-            split_index
-        } else {
+        let Some(split_index) = crate::num::traits::CheckedSub::checked_sub(
+            total_pending_bytes, BYTES_IN_BYTES31,
+        ) else {
             self.pending_word = word + self.pending_word * one_shift_left_bytes_felt252(len);
             self.pending_word_len = total_pending_bytes;
             return;
diff --git a/corelib/src/ecdsa.cairo b/corelib/src/ecdsa.cairo
@@ -112,10 +112,9 @@ pub fn check_ecdsa_signature(
     // Calculate the point `r * Q`.
     let mut rQ_state = init_ec;
     rQ_state.add_mul(signature_r, public_key_point);
-    let rQ = match rQ_state.finalize_nz() {
-        Some(pt) => pt,
+    let Some(rQ) = rQ_state.finalize_nz() else {
         // The zero case is not actually possible, as `signature_r` isn't 0.
-        None => { return false; },
+        return false;
     };
 
     // Check the `(zG + rQ).x = sR.x` case.
diff --git a/corelib/src/math.cairo b/corelib/src/math.cairo
@@ -47,9 +47,7 @@ pub fn egcd<
 ) -> (T, T, T, bool) {
     let (q, r) = DivRem::<T>::div_rem(a.into(), b);
 
-    let r = if let Some(r) = r.try_into() {
-        r
-    } else {
+    let Some(r) = r.try_into() else {
         return (b.into(), core::num::traits::Zero::zero(), core::num::traits::One::one(), false);
     };
 
diff --git a/corelib/src/poseidon.cairo b/corelib/src/poseidon.cairo
@@ -138,15 +138,13 @@ fn _poseidon_hash_span_inner(
     ref span: Span<felt252>,
 ) -> felt252 {
     let (s0, s1, s2) = state;
-    let x = *match span.pop_front() {
-        Some(x) => x,
-        None => { return HashState { s0, s1, s2, odd: false }.finalize(); },
+    let Some(x) = span.pop_front() else {
+        return HashState { s0, s1, s2, odd: false }.finalize();
     };
-    let y = *match span.pop_front() {
-        Some(y) => y,
-        None => { return HashState { s0: s0 + x, s1, s2, odd: true }.finalize(); },
+    let Some(y) = span.pop_front() else {
+        return HashState { s0: s0 + *x, s1, s2, odd: true }.finalize();
     };
-    let next_state = hades_permutation(s0 + x, s1 + y, s2);
+    let next_state = hades_permutation(s0 + *x, s1 + *y, s2);
     crate::gas::withdraw_gas_all(builtin_costs).expect('Out of gas');
     _poseidon_hash_span_inner(builtin_costs, next_state, ref span)
 }
diff --git a/corelib/src/starknet/storage_access.cairo b/corelib/src/starknet/storage_access.cairo
@@ -872,10 +872,9 @@ fn inner_byte_array_pointer(address: StorageAddress, chunk: felt252) -> StorageB
 /// The length of the byte array is read from `address` at domain `address_domain`.
 /// For more info read the documentation of `ByteArrayStore`.
 fn inner_read_byte_array(address_domain: u32, address: StorageAddress) -> SyscallResult<ByteArray> {
-    let len: usize =
-        match starknet::syscalls::storage_read_syscall(address_domain, address)?.try_into() {
-        Some(x) => x,
-        None => { return SyscallResult::Err(array!['Invalid ByteArray length']); },
+    let Some::<usize>(len) = starknet::syscalls::storage_read_syscall(address_domain, address)?
+        .try_into() else {
+        return Err(array!['Invalid ByteArray length']);
     };
     let (mut remaining_full_words, pending_word_len) = core::DivRem::div_rem(
         len, BYTES_IN_BYTES31.try_into().unwrap(),
@@ -886,18 +885,13 @@ fn inner_read_byte_array(address_domain: u32, address: StorageAddress) -> Syscal
     let mut result: ByteArray = Default::default();
     loop {
         if remaining_full_words == 0 {
-            break Ok(());
+            break;
         }
-        let value =
-            match starknet::syscalls::storage_read_syscall(
-                address_domain, storage_address_from_base_and_offset(chunk_base, index_in_chunk),
-            ) {
-            Ok(value) => value,
-            Err(err) => { break Err(err); },
-        };
-        let value: bytes31 = match value.try_into() {
-            Some(x) => x,
-            None => { break Err(array!['Invalid value']); },
+        let value = starknet::syscalls::storage_read_syscall(
+            address_domain, storage_address_from_base_and_offset(chunk_base, index_in_chunk),
+        )?;
+        let Some::<bytes31>(value) = value.try_into() else {
+            return Err(array!['Invalid value']);
         };
         result.data.append(value);
         remaining_full_words -= 1;
@@ -911,7 +905,7 @@ fn inner_read_byte_array(address_domain: u32, address: StorageAddress) -> Syscal
                 0
             },
         };
-    }?;
+    }
     if pending_word_len != 0 {
         let pending_word = starknet::syscalls::storage_read_syscall(
             address_domain, storage_address_from_base_and_offset(chunk_base, index_in_chunk),
diff --git a/crates/bin/cairo-execute/src/main.rs b/crates/bin/cairo-execute/src/main.rs
@@ -333,12 +333,12 @@ fn main() -> anyhow::Result<()> {
         let load_offset = entry_point_offset + header_len;
         let info = ProfilingInfo::from_trace(&builder, load_offset, &Default::default(), trace);
 
-        let profiling_processor = ProfilingInfoProcessor::new(
+        let processed_profiling_info = ProfilingInfoProcessor::new(
             Some(&db),
-            replace_sierra_ids_in_program(&db, builder.sierra_program()),
-            debug_info.statements_locations.get_statements_functions_map_for_tests(&db),
-        );
-        let processed_profiling_info = profiling_processor.process(&info, &Default::default());
+            &replace_sierra_ids_in_program(&db, builder.sierra_program()),
+            &debug_info.statements_locations.get_statements_functions_map_for_tests(&db),
+        )
+        .process(&info, &Default::default());
         println!("{processed_profiling_info}");
     }
 
diff --git a/crates/bin/cairo-run/src/main.rs b/crates/bin/cairo-run/src/main.rs
@@ -99,13 +99,13 @@ fn main() -> anyhow::Result<()> {
         .with_context(|| "Failed to run the function.")?;
 
     if args.run_profiler {
-        let profiling_info_processor = ProfilingInfoProcessor::new(
-            Some(db),
-            sierra_program,
-            debug_info.statements_locations.get_statements_functions_map_for_tests(db),
-        );
         match result.profiling_info {
             Some(raw_profiling_info) => {
+                let statements_functions =
+                    debug_info.statements_locations.get_statements_functions_map_for_tests(db);
+                let profiling_info_processor =
+                    ProfilingInfoProcessor::new(Some(db), &sierra_program, &statements_functions);
+
                 let profiling_info =
                     profiling_info_processor.process(&raw_profiling_info, &Default::default());
                 println!("Profiling info:\n{profiling_info}");
diff --git a/crates/bin/cairo-test/Cargo.toml b/crates/bin/cairo-test/Cargo.toml
@@ -12,4 +12,5 @@ clap.workspace = true
 serde = { workspace = true, default-features = true }
 
 cairo-lang-compiler = { path = "../../cairo-lang-compiler", version = "~2.12.0-rc.2" }
+cairo-lang-runner = { path = "../../cairo-lang-runner", version = "~2.12.0-rc.2" }
 cairo-lang-test-runner = { path = "../../cairo-lang-test-runner", version = "~2.12.0-rc.2" }
diff --git a/crates/bin/cairo-test/src/main.rs b/crates/bin/cairo-test/src/main.rs
@@ -4,11 +4,12 @@ use std::path::PathBuf;
 
 use anyhow::Ok;
 use cairo_lang_compiler::project::check_compiler_path;
-use cairo_lang_test_runner::{RunProfilerConfig, TestRunConfig, TestRunner};
+use cairo_lang_runner::profiling::ProfilerConfig;
+use cairo_lang_test_runner::{TestRunConfig, TestRunner};
 use clap::{Parser, ValueEnum};
 use serde::Serialize;
 
-/// The clap-arg equivalent of [RunProfilerConfig].
+/// A clap-arg wrapper for Option<[ProfilerConfig]>.
 #[derive(ValueEnum, Clone, Default, Debug, Serialize, PartialEq, Eq, Hash)]
 #[serde(rename_all = "kebab-case")]
 enum RunProfilerConfigArg {
@@ -17,12 +18,12 @@ enum RunProfilerConfigArg {
     Cairo,
     Sierra,
 }
-impl From<RunProfilerConfigArg> for RunProfilerConfig {
+impl From<RunProfilerConfigArg> for Option<ProfilerConfig> {
     fn from(val: RunProfilerConfigArg) -> Self {
         match val {
-            RunProfilerConfigArg::None => RunProfilerConfig::None,
-            RunProfilerConfigArg::Cairo => RunProfilerConfig::Cairo,
-            RunProfilerConfigArg::Sierra => RunProfilerConfig::Sierra,
+            RunProfilerConfigArg::None => None,
+            RunProfilerConfigArg::Cairo => Some(ProfilerConfig::Cairo),
+            RunProfilerConfigArg::Sierra => Some(ProfilerConfig::Sierra),
         }
     }
 }
@@ -53,7 +54,7 @@ struct Args {
     #[arg(long, default_value_t = false)]
     starknet: bool,
     /// Whether to run the profiler, and what results to produce. See
-    /// [cairo_lang_test_runner::RunProfilerConfig]
+    /// [cairo_lang_runner::profiling::ProfilerConfig]
     #[arg(short, long, default_value_t, value_enum)]
     run_profiler: RunProfilerConfigArg,
     /// Should disable gas calculation.
@@ -74,7 +75,7 @@ fn main() -> anyhow::Result<()> {
         filter: args.filter,
         ignored: args.ignored,
         include_ignored: args.include_ignored,
-        run_profiler: args.run_profiler.into(),
+        profiler_config: args.run_profiler.into(),
         gas_enabled: !args.gas_disabled,
         print_resource_usage: args.print_resource_usage,
     };
diff --git a/crates/cairo-lang-compiler/src/diagnostics.rs b/crates/cairo-lang-compiler/src/diagnostics.rs
@@ -45,8 +45,9 @@ pub struct DiagnosticsReporter<'a> {
     /// Adding ids that are not in `crate_ids` has no effect.
     ignore_warnings_crate_ids: Vec<CrateId>,
     /// Check diagnostics for these crates only.
-    /// If empty, check all crates in the db.
-    crate_ids: Vec<CrateId>,
+    /// If `None`, check all crates in the db.
+    /// If empty, do not check any crates at all.
+    crate_ids: Option<Vec<CrateId>>,
     /// If true, compilation will not fail due to warnings.
     allow_warnings: bool,
     /// If true, will ignore diagnostics from LoweringGroup during the ensure function.
@@ -58,7 +59,7 @@ impl DiagnosticsReporter<'static> {
     pub fn ignoring() -> Self {
         Self {
             callback: None,
-            crate_ids: vec![],
+            crate_ids: Default::default(),
             ignore_all_warnings: false,
             ignore_warnings_crate_ids: vec![],
             allow_warnings: false,
@@ -103,7 +104,7 @@ impl<'a> DiagnosticsReporter<'a> {
     fn new(callback: impl DiagnosticCallback + 'a) -> Self {
         Self {
             callback: Some(Box::new(callback)),
-            crate_ids: vec![],
+            crate_ids: Default::default(),
             ignore_all_warnings: false,
             ignore_warnings_crate_ids: vec![],
             allow_warnings: false,
@@ -113,7 +114,7 @@ impl<'a> DiagnosticsReporter<'a> {
 
     /// Sets crates to be checked, instead of all crates in the db.
     pub fn with_crates(mut self, crate_ids: &[CrateId]) -> Self {
-        self.crate_ids = crate_ids.to_vec();
+        self.crate_ids = Some(crate_ids.to_vec());
         self
     }
 
@@ -140,7 +141,7 @@ impl<'a> DiagnosticsReporter<'a> {
 
     /// Returns the crate ids for which the diagnostics will be checked.
     fn crates_of_interest(&self, db: &dyn LoweringGroup) -> Vec<CrateId> {
-        if self.crate_ids.is_empty() { db.crates() } else { self.crate_ids.clone() }
+        if let Some(crates) = self.crate_ids.as_ref() { crates.clone() } else { db.crates() }
     }
 
     /// Checks if there are diagnostics and reports them to the provided callback as strings.
@@ -294,8 +295,19 @@ impl Default for DiagnosticsReporter<'static> {
 /// Returns a string with all the diagnostics in the db.
 ///
 /// This is a shortcut for `DiagnosticsReporter::write_to_string(&mut string).check(db)`.
-pub fn get_diagnostics_as_string(db: &RootDatabase, extra_crate_ids: &[CrateId]) -> String {
+///
+/// If `crates_to_check` is `Some`, only diagnostics for these crates will be checked.
+/// If `crates_to_check` is `None`, diagnostics for all crates in the db will be checked.
+pub fn get_diagnostics_as_string(
+    db: &RootDatabase,
+    crates_to_check: Option<Vec<CrateId>>,
+) -> String {
     let mut diagnostics = String::default();
-    DiagnosticsReporter::write_to_string(&mut diagnostics).with_crates(extra_crate_ids).check(db);
+    let mut reporter = DiagnosticsReporter::write_to_string(&mut diagnostics);
+    if let Some(crates) = crates_to_check.as_ref() {
+        reporter = reporter.with_crates(crates);
+    }
+    reporter.check(db);
+    drop(reporter);
     diagnostics
 }
diff --git a/crates/cairo-lang-compiler/src/diagnostics_test.rs b/crates/cairo-lang-compiler/src/diagnostics_test.rs
@@ -14,5 +14,5 @@ fn test_diagnostics() {
         Some(CrateConfiguration::default_for_root(Directory::Real("no/such/path".into()))),
     );
 
-    assert_eq!(get_diagnostics_as_string(&db, &[]), "error: no/such/path/lib.cairo not found\n");
+    assert_eq!(get_diagnostics_as_string(&db, None), "error: no/such/path/lib.cairo not found\n");
 }
diff --git a/crates/cairo-lang-formatter/src/node_properties.rs b/crates/cairo-lang-formatter/src/node_properties.rs
@@ -384,7 +384,8 @@ impl SyntaxNodeFormat for SyntaxNode {
                         | SyntaxKind::ExprListParenthesized
                         | SyntaxKind::ArgListBraced
                         | SyntaxKind::ArgListBracketed
-                        | SyntaxKind::ExprUnary => Some(1),
+                        | SyntaxKind::ExprUnary => Some(9),
+                        SyntaxKind::LetElseClause => Some(7),
                         SyntaxKind::TerminalEq => Some(10),
                         SyntaxKind::PatternEnum
                         | SyntaxKind::PatternTuple
diff --git a/crates/cairo-lang-formatter/test_data/cairo_files/linebreaking.cairo b/crates/cairo-lang-formatter/test_data/cairo_files/linebreaking.cairo
@@ -82,6 +82,14 @@ fn comment_remains_after_last_comma() {
 fn struct_line_breaking() {
     let MyStruct {long_long_long_long_key_a, long_long_long_long_key_b, long_long_long_long_key_c, long_long_long_long_key_d, long_long_long_long_key_e, } = my_val;
 }
+fn let_else_line_breaking() {
+    let MyEnum::MyVariant(info) = my_val
+        .calc0()
+        .calc1()
+        .calc2() else {
+            return rather_long_return_value;
+        };
+}
 fn closure_line_breaking() {
     let closure_with_a_very_very_very_very_very_very_very_very_large_name = |left: usize, right: usize| -> usize {
             left + right
diff --git a/crates/cairo-lang-formatter/test_data/expected_results/linebreaking.cairo b/crates/cairo-lang-formatter/test_data/expected_results/linebreaking.cairo
@@ -306,6 +306,11 @@ fn struct_line_breaking() {
         long_long_long_long_key_e,
     } = my_val;
 }
+fn let_else_line_breaking() {
+    let MyEnum::MyVariant(info) = my_val.calc0().calc1().calc2() else {
+        return rather_long_return_value;
+    };
+}
 fn closure_line_breaking() {
     let closure_with_a_very_very_very_very_very_very_very_very_large_name = |
         left: usize, right: usize,
diff --git a/crates/cairo-lang-runner/src/profiling.rs b/crates/cairo-lang-runner/src/profiling.rs
diff --git a/crates/cairo-lang-runner/src/profiling_test.rs b/crates/cairo-lang-runner/src/profiling_test.rs
diff --git a/crates/cairo-lang-starknet/cairo_level_tests/storage_access.cairo b/crates/cairo-lang-starknet/cairo_level_tests/storage_access.cairo
diff --git a/crates/cairo-lang-starknet/src/plugin/test.rs b/crates/cairo-lang-starknet/src/plugin/test.rs
diff --git a/crates/cairo-lang-test-runner/src/lib.rs b/crates/cairo-lang-test-runner/src/lib.rs
