fix: replace deprecated #[clap(...)] with #[command(...)] and #[arg(...)] (#413)

CHANGELOG.md

@@ -1,5 +1,6 @@
 ## 0.15.0 (TBD)
 
+- Replace deprecated #[clap(...)] with #[command(...)] and #[arg(...)] (#413).
 - Added default constructors to `MmrPeaks` and `PartialMmr` (#409).
 - Add module and function documentation. (#408).
 

miden-crypto/benches/merkle.rs

@@ -5,7 +5,7 @@
 //! tree will perform better than the sparse version. At the time of this writing (2024/11/24), this
 //! benchmark is about four times more efficient than the equivalent benchmark in
 //! `benches/smt-subtree.rs`.
-use std::{hint, mem, time::Duration};
+use std::{hint, time::Duration};
 
 use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 use miden_crypto::{Felt, ONE, Word, merkle::MerkleTree};
@@ -60,7 +60,7 @@ criterion_main!(smt_subtree_group);
 // --------------------------------------------------------------------------------------------
 
 fn generate_word(seed: &mut [u8; 32]) -> Word {
-    mem::swap(seed, &mut prng_array(*seed));
+    *seed = prng_array(*seed);
     let nums: [u64; 4] = prng_array(*seed);
     [Felt::new(nums[0]), Felt::new(nums[1]), Felt::new(nums[2]), Felt::new(nums[3])]
 }

miden-crypto/benches/smt-subtree.rs

@@ -1,4 +1,4 @@
-use std::{fmt::Debug, hint, mem, time::Duration};
+use std::{fmt::Debug, hint, time::Duration};
 
 use criterion::{BatchSize, BenchmarkId, Criterion, criterion_group, criterion_main};
 use miden_crypto::{
@@ -131,13 +131,13 @@ criterion_main!(smt_subtree_group);
 // --------------------------------------------------------------------------------------------
 
 fn generate_value<T: Copy + Debug + Randomizable>(seed: &mut [u8; 32]) -> T {
-    mem::swap(seed, &mut prng_array(*seed));
+    *seed = prng_array(*seed);
     let value: [T; 1] = rand_utils::prng_array(*seed);
     value[0]
 }
 
 fn generate_word(seed: &mut [u8; 32]) -> Word {
-    mem::swap(seed, &mut prng_array(*seed));
+    *seed = prng_array(*seed);
     let nums: [u64; 4] = prng_array(*seed);
     [Felt::new(nums[0]), Felt::new(nums[1]), Felt::new(nums[2]), Felt::new(nums[3])]
 }

miden-crypto/benches/smt-with-entries.rs

@@ -1,4 +1,4 @@
-use std::{fmt::Debug, hint, mem, time::Duration};
+use std::{fmt::Debug, hint, time::Duration};
 
 use criterion::{BatchSize, BenchmarkId, Criterion, criterion_group, criterion_main};
 use miden_crypto::{Felt, ONE, Word, hash::rpo::RpoDigest, merkle::Smt};
@@ -59,13 +59,13 @@ fn prepare_entries(pair_count: u64, seed: &mut [u8; 32]) -> Vec<(RpoDigest, [Fel
 }
 
 fn generate_value<T: Copy + Debug + Randomizable>(seed: &mut [u8; 32]) -> T {
-    mem::swap(seed, &mut prng_array(*seed));
+    *seed = prng_array(*seed);
     let value: [T; 1] = rand_utils::prng_array(*seed);
     value[0]
 }
 
 fn generate_word(seed: &mut [u8; 32]) -> Word {
-    mem::swap(seed, &mut prng_array(*seed));
+    *seed = prng_array(*seed);
     let nums: [u64; 4] = prng_array(*seed);
     [Felt::new(nums[0]), Felt::new(nums[1]), Felt::new(nums[2]), Felt::new(nums[3])]
 }

miden-crypto/benches/smt.rs

@@ -1,5 +1,3 @@
-use core::mem::swap;
-
 use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use miden_crypto::{
     Felt, Word,
@@ -71,7 +69,7 @@ criterion_main!(smt_group);
 // --------------------------------------------------------------------------------------------
 
 fn generate_word(seed: &mut [u8; 32]) -> Word {
-    swap(seed, &mut prng_array(*seed));
+    *seed = prng_array(*seed);
     let nums: [u64; 4] = prng_array(*seed);
     [Felt::new(nums[0]), Felt::new(nums[1]), Felt::new(nums[2]), Felt::new(nums[3])]
 }

miden-crypto/src/hash/rescue/rpo/digest.rs

@@ -126,7 +126,7 @@ impl PartialOrd for RpoDigest {
 impl Display for RpoDigest {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let encoded: String = self.into();
-        write!(f, "{}", encoded)?;
+        write!(f, "{encoded}")?;
         Ok(())
     }
 }

miden-crypto/src/hash/rescue/rpx/digest.rs

@@ -108,7 +108,7 @@ impl PartialOrd for RpxDigest {
 impl Display for RpxDigest {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let encoded: String = self.into();
-        write!(f, "{}", encoded)?;
+        write!(f, "{encoded}")?;
         Ok(())
     }
 }

miden-crypto/src/main.rs

@@ -10,16 +10,16 @@ use rand::{Rng, prelude::IteratorRandom, rng};
 use rand_utils::rand_value;
 
 #[derive(Parser, Debug)]
-#[clap(name = "Benchmark", about = "SMT benchmark", version, rename_all = "kebab-case")]
+#[command(name = "Benchmark", about = "SMT benchmark", version, rename_all = "kebab-case")]
 pub struct BenchmarkCmd {
     /// Size of the tree
-    #[clap(short = 's', long = "size", default_value = "1000000")]
+    #[arg(short = 's', long = "size", default_value = "1000000")]
     size: usize,
     /// Number of insertions
-    #[clap(short = 'i', long = "insertions", default_value = "1000")]
+    #[arg(short = 'i', long = "insertions", default_value = "1000")]
     insertions: usize,
     /// Number of updates
-    #[clap(short = 'u', long = "updates", default_value = "1000")]
+    #[arg(short = 'u', long = "updates", default_value = "1000")]
     updates: usize,
 }
 

miden-crypto/src/merkle/mmr/partial.rs

@@ -246,9 +246,7 @@ impl PartialMmr {
 
                     debug_assert!(
                         old.is_none(),
-                        "Idx {:?} already contained an element {:?}",
+                        "Idx {left_idx:?} already contained an element {old:?}",
-                        left_idx,
-                        old
                     );
                 };
                 if track_left {
@@ -257,9 +255,7 @@ impl PartialMmr {
 
                     debug_assert!(
                         old.is_none(),
-                        "Idx {:?} already contained an element {:?}",
+                        "Idx {right_idx:?} already contained an element {old:?}",
-                        right_idx,
-                        old
                     );
                 };
 

miden-crypto/src/merkle/smt/full/concurrent/tests.rs

@@ -247,8 +247,7 @@ fn test_singlethreaded_subtrees() {
                     let control_node = control.get_inner_node(index);
                     assert_eq!(
                         test_node, &control_node,
-                        "depth {} subtree {}: test node does not match control at index {:?}",
+                        "depth {current_depth} subtree {i}: test node does not match control at index {index:?}",
-                        current_depth, i, index,
                     );
                 }
                 (nodes, subtree_root)
@@ -329,8 +328,7 @@ fn test_multithreaded_subtrees() {
                     let control_node = control.get_inner_node(index);
                     assert_eq!(
                         test_node, &control_node,
-                        "depth {} subtree {}: test node does not match control at index {:?}",
+                        "depth {current_depth} subtree {i}: test node does not match control at index {index:?}",
-                        current_depth, i, index,
                     );
                 }
                 (nodes, subtree_root)
@@ -428,8 +426,7 @@ fn test_singlethreaded_subtree_mutations() {
                     let control_mutation = control.node_mutations().get(&index).unwrap();
                     assert_eq!(
                         control_mutation, mutation,
-                        "depth {} subtree {}: mutation does not match control at index {:?}",
+                        "depth {current_depth} subtree {i}: mutation does not match control at index {index:?}",
-                        current_depth, i, index,
                     );
                 }
                 (mutations_per_subtree, subtree_root)

miden-crypto/src/merkle/sparse_path.rs

@@ -154,16 +154,14 @@ impl Deserializable for SparseMerklePath {
         let depth = source.read_u8()?;
         if depth > SMT_MAX_DEPTH {
             return Err(DeserializationError::InvalidValue(format!(
-                "SparseMerklePath max depth exceeded ({} > {})",
+                "SparseMerklePath max depth exceeded ({depth} > {SMT_MAX_DEPTH})",
-                depth, SMT_MAX_DEPTH
             )));
         }
         let empty_nodes_mask = source.read_u64()?;
         let empty_nodes_count = empty_nodes_mask.count_ones();
         if empty_nodes_count > depth as u32 {
             return Err(DeserializationError::InvalidValue(format!(
-                "SparseMerklePath has more empty nodes ({}) than its full length ({})",
+                "SparseMerklePath has more empty nodes ({empty_nodes_count}) than its full length ({depth})",
-                empty_nodes_count, depth
             )));
         }
         let count = depth as u32 - empty_nodes_count;