chore: bump rust toolchain to 1.95.0

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.94.0"
+channel = "1.95.0"
 components = ["clippy", "llvm-tools-preview", "rustfmt"]

src/blocks/tipset.rs

@@ -741,10 +741,9 @@ mod lotus_json {
     }
 
     #[cfg(test)]
-    quickcheck::quickcheck! {
-        fn quickcheck(val: Tipset) -> () {
-            assert_unchanged_via_json(val)
-        }
+    #[quickcheck_macros::quickcheck]
+    fn quickcheck(val: Tipset) {
+        assert_unchanged_via_json(val)
     }
 }
 

src/cid_collections/hash_map.rs

@@ -352,8 +352,6 @@ impl<V> Iterator for Keys<'_, V> {
 mod tests {
     use super::*;
 
-    use quickcheck::quickcheck;
-
     #[derive(derive_quickcheck_arbitrary::Arbitrary, Clone, Debug)]
     enum Operation {
         ContainsKey(MaybeCompactedCid),
@@ -362,56 +360,47 @@ mod tests {
         Entry { key: MaybeCompactedCid, value: u8 },
     }
 
-    quickcheck! {
-        fn operations(operations: Vec<Operation>) -> () {
-            use Operation as Op;
-
-            let mut subject = CidHashMap::default();
-            let mut reference = ahash::HashMap::default();
-            for operation in operations {
-                match operation {
-                    Op::ContainsKey(key) => {
-                        let key = key.into();
-                        assert_eq!(
-                            subject.contains_key(&key),
-                            reference.contains_key(&key)
-                        )
-                    },
-                    Op::Get(key) => {
-                        let key = key.into();
-                        assert_eq!(
-                            subject.get(&key),
-                            reference.get(&key)
-                        )
-                    },
-                    Op::Insert(key, val) => {
-                        let key = key.into();
-                        assert_eq!(
-                            subject.insert(key, val),
-                            reference.insert(key, val)
-                        )
-                    },
-                    Op::Entry {
-                        key, value
-                    } => {
-                        let key = key.into();
-                        match (subject.entry(key), reference.entry(key)) {
-                            (Entry::Occupied(subj), StdEntry::Occupied(refr)) => assert_eq!(subj.get(), refr.get()),
-                            (Entry::Vacant(subj), StdEntry::Vacant(refr)) => assert_eq!(subj.insert(value), refr.insert(value)),
-                            (subj, refr) => panic!("{subj:?}, {refr:?}")
+    #[quickcheck_macros::quickcheck]
+    fn operations(operations: Vec<Operation>) {
+        use Operation as Op;
+
+        let mut subject = CidHashMap::default();
+        let mut reference = ahash::HashMap::default();
+        for operation in operations {
+            match operation {
+                Op::ContainsKey(key) => {
+                    let key = key.into();
+                    assert_eq!(subject.contains_key(&key), reference.contains_key(&key))
+                }
+                Op::Get(key) => {
+                    let key = key.into();
+                    assert_eq!(subject.get(&key), reference.get(&key))
+                }
+                Op::Insert(key, val) => {
+                    let key = key.into();
+                    assert_eq!(subject.insert(key, val), reference.insert(key, val))
+                }
+                Op::Entry { key, value } => {
+                    let key = key.into();
+                    match (subject.entry(key), reference.entry(key)) {
+                        (Entry::Occupied(subj), StdEntry::Occupied(refr)) => {
+                            assert_eq!(subj.get(), refr.get())
                         }
+                        (Entry::Vacant(subj), StdEntry::Vacant(refr)) => {
+                            assert_eq!(subj.insert(value), refr.insert(value))
+                        }
+                        (subj, refr) => panic!("{subj:?}, {refr:?}"),
                     }
                 }
-            };
-            assert_eq!(reference, ahash::HashMap::from_iter(subject));
+            }
         }
+        assert_eq!(reference, ahash::HashMap::from_iter(subject));
+    }
 
-        fn collect(pairs: Vec<(Cid, u8)>) -> () {
-            let refr = ahash::HashMap::from_iter(pairs.clone());
-            let via_subject = ahash::HashMap::from_iter(
-                CidHashMap::from_iter(pairs)
-            );
-            assert_eq!(refr, via_subject);
-        }
+    #[quickcheck_macros::quickcheck]
+    fn collect(pairs: Vec<(Cid, u8)>) {
+        let refr = ahash::HashMap::from_iter(pairs.clone());
+        let via_subject = ahash::HashMap::from_iter(CidHashMap::from_iter(pairs));
+        assert_eq!(refr, via_subject);
     }
 }

src/cid_collections/mod.rs

@@ -169,7 +169,7 @@ mod imp {
 mod tests {
     use super::*;
     use cid::Cid;
-    use quickcheck::{Arbitrary, quickcheck};
+    use quickcheck::Arbitrary;
 
     impl Arbitrary for MaybeCompactedCid {
         fn arbitrary(g: &mut quickcheck::Gen) -> Self {
@@ -180,11 +180,10 @@ mod tests {
         }
     }
 
-    quickcheck! {
-        fn cid_via_maybe_compacted_cid(before: Cid) -> () {
-            let via = MaybeCompactedCid::from(before);
-            let after = Cid::from(via);
-            assert_eq!(before, after);
-        }
+    #[quickcheck_macros::quickcheck]
+    fn cid_via_maybe_compacted_cid(before: Cid) {
+        let via = MaybeCompactedCid::from(before);
+        let after = Cid::from(via);
+        assert_eq!(before, after);
     }
 }

src/cli/humantoken.rs

@@ -642,27 +642,23 @@ mod print {
 
 #[cfg(test)]
 mod fuzz {
-    use quickcheck::quickcheck;
-
     use super::*;
 
-    quickcheck! {
-        fn roundtrip(expected: crate::shim::econ::TokenAmount) -> () {
-            // Default formatting
-            let actual = parse(&format!("{}", expected.pretty())).unwrap();
-            assert_eq!(expected, actual);
+    #[quickcheck_macros::quickcheck]
+    fn roundtrip(expected: crate::shim::econ::TokenAmount) {
+        // Default formatting
+        let actual = parse(&format!("{}", expected.pretty())).unwrap();
+        assert_eq!(expected, actual);
 
-            // Absolute formatting
-            let actual = parse(&format!("{:#}", expected.pretty())).unwrap();
-            assert_eq!(expected, actual);
+        // Absolute formatting
+        let actual = parse(&format!("{:#}", expected.pretty())).unwrap();
+        assert_eq!(expected, actual);
 
-            // Don't test rounded formatting...
-        }
+        // Don't test rounded formatting...
     }
 
-    quickcheck! {
-        fn parser_no_panic(s: String) -> () {
-            let _ = parse(&s);
-        }
+    #[quickcheck_macros::quickcheck]
+    fn parser_no_panic(s: String) {
+        let _ = parse(&s);
     }
 }

src/cli/subcommands/net_cmd.rs

@@ -72,12 +72,7 @@ impl NetCommands {
                     .into_iter()
                     .map(|res| res.unwrap_or_else(|_| "<agent unknown>".to_owned()));
 
-                    HashMap::from_iter(
-                        addrs
-                            .iter()
-                            .map(|info| info.id.to_owned())
-                            .zip(agents.into_iter()),
-                    )
+                    HashMap::from_iter(addrs.iter().map(|info| info.id.to_owned()).zip(agents))
                 } else {
                     HashMap::default()
                 };

src/db/car/forest/index/hash.rs

@@ -65,13 +65,14 @@ mod tests {
     use super::*;
     use crate::utils::{cid::CidCborExt as _, multihash::prelude::*};
 
-    quickcheck::quickcheck! {
-        fn always_in_range(hash: NonMaximalU64, num_buckets: NonZeroUsize) -> bool {
-            ideal_slot_ix(hash, num_buckets) < num_buckets.get()
-        }
-        fn backwards(ideal: usize, num_buckets: NonZeroUsize) -> () {
-            do_backwards(ideal, num_buckets)
-        }
+    #[quickcheck_macros::quickcheck]
+    fn always_in_range(hash: NonMaximalU64, num_buckets: NonZeroUsize) -> bool {
+        ideal_slot_ix(hash, num_buckets) < num_buckets.get()
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn backwards(ideal: usize, num_buckets: NonZeroUsize) {
+        do_backwards(ideal, num_buckets)
     }
 
     fn do_backwards(ideal: usize, num_buckets: NonZeroUsize) {

src/db/car/forest/index/mod.rs

@@ -889,38 +889,59 @@ mod tests {
         }
     }
 
-    quickcheck::quickcheck! {
-        fn hashmap_of_cids(reference: HashMap<Cid, HashSet<u64>>) -> () {
-            do_hashmap_of_cids(reference)
-        }
-        fn hashmap_of_hashes(reference: HashMap<NonMaximalU64, HashSet<u64>>) -> () {
-            do_hashmap_of_hashes(reference)
-        }
-        fn everything_maps_to_first_slot(values: Vec<HashSet<u64>>) -> () {
-            let Some(initial_width) = initial_width(values.iter().map(HashSet::len).sum(), DEFAULT_LOAD_FACTOR) else {
-                return;
-            };
-            let reference = HashMap::from_iter(iter::zip(hash::from_ideal_slot_ix(0, initial_width).unique(), values));
-            do_hashmap_of_hashes(reference)
-        }
-        fn everything_maps_to_first_10_slots(values: Vec<HashSet<u64>>) -> () {
-            let Some(initial_width) = initial_width(values.iter().map(HashSet::len).sum(), DEFAULT_LOAD_FACTOR) else {
-                return;
-            };
-            let mut generators = Vec::from_iter((0..cmp::min(initial_width.get(), 10)).map(|it|hash::from_ideal_slot_ix(it, initial_width).unique()));
-            let hashes_in_first_10 = generators.iter_mut().flatten();
-            let reference = HashMap::from_iter(iter::zip(hashes_in_first_10, values));
-            do_hashmap_of_hashes(reference)
-        }
-        fn header(it: V1Header) -> () {
-            round_trip(&it);
-        }
-        fn slot(it: Slot) -> () {
-            round_trip(&it);
-        }
-        fn raw_slot(it: RawSlot) -> () {
-            round_trip(&it);
-        }
+    #[quickcheck_macros::quickcheck]
+    fn hashmap_of_cids(reference: HashMap<Cid, HashSet<u64>>) {
+        do_hashmap_of_cids(reference)
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn hashmap_of_hashes(reference: HashMap<NonMaximalU64, HashSet<u64>>) {
+        do_hashmap_of_hashes(reference)
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn everything_maps_to_first_slot(values: Vec<HashSet<u64>>) {
+        let Some(initial_width) =
+            initial_width(values.iter().map(HashSet::len).sum(), DEFAULT_LOAD_FACTOR)
+        else {
+            return;
+        };
+        let reference = HashMap::from_iter(iter::zip(
+            hash::from_ideal_slot_ix(0, initial_width).unique(),
+            values,
+        ));
+        do_hashmap_of_hashes(reference)
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn everything_maps_to_first_10_slots(values: Vec<HashSet<u64>>) {
+        let Some(initial_width) =
+            initial_width(values.iter().map(HashSet::len).sum(), DEFAULT_LOAD_FACTOR)
+        else {
+            return;
+        };
+        let mut generators = Vec::from_iter(
+            (0..cmp::min(initial_width.get(), 10))
+                .map(|it| hash::from_ideal_slot_ix(it, initial_width).unique()),
+        );
+        let hashes_in_first_10 = generators.iter_mut().flatten();
+        let reference = HashMap::from_iter(iter::zip(hashes_in_first_10, values));
+        do_hashmap_of_hashes(reference)
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn header(it: V1Header) {
+        round_trip(&it);
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn slot(it: Slot) {
+        round_trip(&it);
+    }
+
+    #[quickcheck_macros::quickcheck]
+    fn raw_slot(it: RawSlot) {
+        round_trip(&it);
     }
 
     #[track_caller]

src/db/gc/snapshot.rs

@@ -278,11 +278,9 @@ where
         // Unsubscribe before taking the snapshot of in-memory db to avoid deadlock
         db.unsubscribe_write_ops();
         match joinset.join_next().await {
-            Some(Ok(map)) => {
-                if !map.is_empty() {
-                    *self.memory_db.write() = Some(map);
-                    *self.memory_db_head_key.write() = current_chain_head;
-                }
+            Some(Ok(map)) if !map.is_empty() => {
+                *self.memory_db.write() = Some(map);
+                *self.memory_db_head_key.write() = current_chain_head;
             }
             Some(Err(e)) => tracing::warn!("{e}"),
             _ => {}

src/db/memory.rs

@@ -117,8 +117,8 @@ impl EthMappingsStore for MemoryDB {
         let cids = self
             .eth_mappings_db
             .read()
-            .iter()
-            .filter_map(|(_, value)| fvm_ipld_encoding::from_slice::<(Cid, u64)>(value).ok())
+            .values()
+            .filter_map(|value| fvm_ipld_encoding::from_slice::<(Cid, u64)>(value).ok())
             .collect();
 
         Ok(cids)

src/eth/transaction.rs

@@ -636,7 +636,7 @@ pub(crate) mod tests {
         // from which the chain ID is derived.
         let v = (2 * eth_chain_id + 35).to_biguint().unwrap().to_bytes_be();
         let eip_155_sig_len = calc_valid_eip155_sig_len(eth_chain_id).0 as usize;
-        let mut eip_155_sig = vec![0u8; eip_155_sig_len as usize - v.len()];
+        let mut eip_155_sig = vec![0u8; eip_155_sig_len - v.len()];
         eip_155_sig[0] = EIP_155_SIG_PREFIX;
         eip_155_sig.extend(v);
 

src/libp2p/discovery.rs

@@ -365,22 +365,18 @@ impl NetworkBehaviour for DiscoveryBehaviour {
 
     fn on_swarm_event(&mut self, event: FromSwarm) {
         match &event {
-            FromSwarm::ConnectionEstablished(e) => {
-                if e.other_established == 0 {
-                    self.n_node_connected += 1;
-                    self.peers.insert(e.peer_id);
-                    self.pending_events
-                        .push_back(DiscoveryEvent::PeerConnected(e.peer_id));
-                }
+            FromSwarm::ConnectionEstablished(e) if e.other_established == 0 => {
+                self.n_node_connected += 1;
+                self.peers.insert(e.peer_id);
+                self.pending_events
+                    .push_back(DiscoveryEvent::PeerConnected(e.peer_id));
             }
-            FromSwarm::ConnectionClosed(e) => {
-                if e.remaining_established == 0 {
-                    self.n_node_connected -= 1;
-                    self.peers.remove(&e.peer_id);
-                    self.peer_info.remove(&e.peer_id);
-                    self.pending_events
-                        .push_back(DiscoveryEvent::PeerDisconnected(e.peer_id));
-                }
+            FromSwarm::ConnectionClosed(e) if e.remaining_established == 0 => {
+                self.n_node_connected -= 1;
+                self.peers.remove(&e.peer_id);
+                self.peer_info.remove(&e.peer_id);
+                self.pending_events
+                    .push_back(DiscoveryEvent::PeerDisconnected(e.peer_id));
             }
             _ => {}
         };