chore: Enable rust-2024-compatibility lints

Accept the new rules for the `expr` fragment specifier in declarative
macros, as it only pertains to internal macros.

Accept the new scoping rules of `if-let`, since the new rules don't
affect the one place it applies.

Author: jan-ferdinand

Cargo.toml

@@ -18,3 +18,8 @@ lto = "thin"
 [workspace.dependencies.tasm-object-derive]
 version = "0.48.0"
 path = "tasm-object-derive"
+
+[workspace.lints.rust]
+edition-2024-expr-fragment-specifier = "allow"  # accept the new `expr` fragment specifier rules
+if-let-rescope = "allow"                        # accept the new `if-let` scope
+rust-2024-compatibility = "warn"

tasm-lib/Cargo.toml

@@ -42,3 +42,6 @@ triton-vm = { version = "0.48.0", default-features = false }
 version = "1"
 default-features = false
 features = ["user-hooks"]
+
+[lints]
+workspace = true

tasm-lib/src/arithmetic/u128/safe_add.rs

@@ -93,7 +93,7 @@ mod tests {
             edge_case_points
                 .iter()
                 .cartesian_product(&edge_case_points)
-                .filter(|(&l, &r)| l.checked_add(r).is_some())
+                .filter(|&(&l, &r)| l.checked_add(r).is_some())
                 .map(|(&l, &r)| (l, r))
                 .collect()
         }

tasm-lib/src/arithmetic/u64/add.rs

@@ -98,7 +98,7 @@ mod tests {
             corner_case_points
                 .iter()
                 .cartesian_product(&corner_case_points)
-                .filter(|(&l, &r)| l.checked_add(r).is_some())
+                .filter(|&(&l, &r)| l.checked_add(r).is_some())
                 .map(|(&l, &r)| (l, r))
                 .collect()
         }

tasm-lib/src/arithmetic/u64/sub.rs

@@ -128,7 +128,7 @@ mod tests {
             edge_case_values
                 .iter()
                 .cartesian_product(&edge_case_values)
-                .filter(|(&subtrahend, &minuend)| minuend.checked_sub(subtrahend).is_some())
+                .filter(|&(&subtrahend, &minuend)| minuend.checked_sub(subtrahend).is_some())
                 .map(|(&subtrahend, &minuend)| (subtrahend, minuend))
                 .collect()
         }

tasm-lib/src/list/higher_order/map.rs

@@ -82,11 +82,12 @@ impl<const NUM_INPUT_LISTS: usize> ChainMap<NUM_INPUT_LISTS> {
     /// [len]: BFieldCodec::static_length
     /// [bfe]: DataType::Bfe
     pub fn new(f: InnerFunction) -> Self {
-        if let Some(input_len) = f.domain().static_length() {
+        let domain = f.domain();
+        if let Some(input_len) = domain.static_length() {
             // need instruction `place {input_type.stack_size()}`
             assert!(input_len < OpStackElement::COUNT);
         } else {
-            let DataType::Tuple(tuple) = f.domain() else {
+            let DataType::Tuple(tuple) = domain else {
                 panic!("{INNER_FN_INCORRECT_INPUT_DYN_LEN}");
             };
             let [_, DataType::Bfe] = tuple[..] else {

tasm-lib/src/mmr/verify_mmr_successor.rs

@@ -581,7 +581,7 @@ mod tests {
 
             for peak_idx in 0..old.peaks().len() {
                 let mut wrong_old_peaks = old.peaks();
-                let Digest(ref mut digest_to_disturb) = &mut wrong_old_peaks[peak_idx];
+                let Digest(ref mut digest_to_disturb) = wrong_old_peaks[peak_idx];
                 let digest_to_disturb_innards_idx = rng.random_range(0..Digest::LEN);
                 digest_to_disturb[digest_to_disturb_innards_idx].increment();
 
@@ -592,7 +592,7 @@ mod tests {
             for proof_path_idx in 0..proof.paths.len() {
                 let mut wrong_proof = proof.clone();
                 let proof_paths = &mut wrong_proof.paths;
-                let Digest(ref mut digest_to_disturb) = &mut proof_paths[proof_path_idx];
+                let Digest(ref mut digest_to_disturb) = proof_paths[proof_path_idx];
                 let digest_to_disturb_innards_idx = rng.random_range(0..Digest::LEN);
                 digest_to_disturb[digest_to_disturb_innards_idx].increment();
 

tasm-lib/src/test_helpers.rs

@@ -115,10 +115,10 @@ pub(crate) fn verify_memory_equivalence(
 
     let in_a_and_different_in_b = a_memory
         .iter()
-        .filter(|(k, &v)| b_memory.get(k).map(|&b| b != v).unwrap_or(true));
+        .filter(|&(k, v)| b_memory.get(k).map(|b| b != v).unwrap_or(true));
     let in_b_and_different_in_a = b_memory
         .iter()
-        .filter(|(k, &v)| a_memory.get(k).map(|&b| b != v).unwrap_or(true));
+        .filter(|&(k, v)| a_memory.get(k).map(|b| b != v).unwrap_or(true));
 
     let in_a_and_different_in_b = format_hash_map_iterator(in_a_and_different_in_b);
     let in_b_and_different_in_a = format_hash_map_iterator(in_b_and_different_in_a);

tasm-lib/src/verifier/fri/verify_fri_authentication_paths.rs

@@ -384,8 +384,7 @@ mod tests {
         let mut initial_state = VerifyFriAuthenticationPaths.pseudorandom_initial_state(seed, None);
         let auth_paths = &mut initial_state.nondeterminism.digests;
         let digest_index = digest_index % auth_paths.len();
-        let auth_path_element = &mut auth_paths[digest_index];
-        let Digest(ref mut auth_path_element_innards) = auth_path_element;
+        let Digest(ref mut auth_path_element_innards) = auth_paths[digest_index];
         auth_path_element_innards[perturbation_index] += bfe!(perturbation);
 
         test_assertion_failure(

tasm-object-derive/Cargo.toml

@@ -23,3 +23,6 @@ proc-macro = true
 
 [dev-dependencies]
 prettyplease = "0.2.29"
+
+[lints]
+workspace = true