Fix Rust beta compiler errors (1.77) (#5180)

* Lint fixes

* More fixes for beta compiler.

* Format fixes

* Move `#[allow(dead_code)]` to field level.

* Remove old comment.

* Update beacon_node/execution_layer/src/test_utils/mod.rs

Co-authored-by: João Oliveira <hello@jxs.pt>

* remove duplicate line

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -539,8 +539,8 @@ impl<'a, T: BeaconChainTypes> IndexedAggregatedAttestation<'a, T> {
             Err(e) => return Err(SignatureNotChecked(&signed_aggregate.message.aggregate, e)),
         };
 
-        let indexed_attestation =
-            match map_attestation_committee(chain, attestation, |(committee, _)| {
+        let get_indexed_attestation_with_committee =
+            |(committee, _): (BeaconCommittee, CommitteesPerSlot)| {
                 // Note: this clones the signature which is known to be a relatively slow operation.
                 //
                 // Future optimizations should remove this clone.
@@ -561,11 +561,17 @@ impl<'a, T: BeaconChainTypes> IndexedAggregatedAttestation<'a, T> {
 
                 get_indexed_attestation(committee.committee, attestation)
                     .map_err(|e| BeaconChainError::from(e).into())
-            }) {
-                Ok(indexed_attestation) => indexed_attestation,
-                Err(e) => return Err(SignatureNotChecked(&signed_aggregate.message.aggregate, e)),
             };
 
+        let indexed_attestation = match map_attestation_committee(
+            chain,
+            attestation,
+            get_indexed_attestation_with_committee,
+        ) {
+            Ok(indexed_attestation) => indexed_attestation,
+            Err(e) => return Err(SignatureNotChecked(&signed_aggregate.message.aggregate, e)),
+        };
+
         Ok(IndexedAggregatedAttestation {
             signed_aggregate,
             indexed_attestation,

beacon_node/beacon_chain/src/eth1_chain.rs

@@ -967,7 +967,7 @@ mod test {
             let spec = &E::default_spec();
             let state: BeaconState<E> = BeaconState::new(0, get_eth1_data(0), spec);
 
-            let blocks = vec![];
+            let blocks = [];
 
             assert_eq!(
                 get_votes_to_consider(

beacon_node/beacon_chain/src/state_advance_timer.rs

@@ -51,7 +51,8 @@ const MAX_BLOCK_PRODUCTION_CACHE_DISTANCE: u64 = 4;
 #[derive(Debug)]
 enum Error {
     BeaconChain(BeaconChainError),
-    HeadMissingFromSnapshotCache(Hash256),
+    // We don't use the inner value directly, but it's used in the Debug impl.
+    HeadMissingFromSnapshotCache(#[allow(dead_code)] Hash256),
     MaxDistanceExceeded {
         current_slot: Slot,
         head_slot: Slot,

beacon_node/execution_layer/src/test_utils/mock_builder.rs

@@ -54,7 +54,8 @@ impl Operation {
 }
 
 #[derive(Debug)]
-struct Custom(String);
+// We don't use the string value directly, but it's used in the Debug impl which is required by `warp::reject::Reject`.
+struct Custom(#[allow(dead_code)] String);
 
 impl warp::reject::Reject for Custom {}
 

beacon_node/execution_layer/src/test_utils/mod.rs

@@ -599,8 +599,8 @@ async fn handle_rejection(err: Rejection) -> Result<impl warp::Reply, Infallible
     let code;
     let message;
 
-    if let Some(e) = err.find::<AuthError>() {
-        message = format!("Authorization error: {:?}", e);
+    if let Some(AuthError(e)) = err.find::<AuthError>() {
+        message = format!("Authorization error: {}", e);
         code = StatusCode::UNAUTHORIZED;
     } else {
         message = "BAD_REQUEST".to_string();

beacon_node/http_api/src/attestation_performance.rs

@@ -14,11 +14,12 @@ const MAX_REQUEST_RANGE_EPOCHS: usize = 100;
 const BLOCK_ROOT_CHUNK_SIZE: usize = 100;
 
 #[derive(Debug)]
+// We don't use the inner values directly, but they're used in the Debug impl.
 enum AttestationPerformanceError {
-    BlockReplay(BlockReplayError),
-    BeaconState(BeaconStateError),
-    ParticipationCache(ParticipationCacheError),
-    UnableToFindValidator(usize),
+    BlockReplay(#[allow(dead_code)] BlockReplayError),
+    BeaconState(#[allow(dead_code)] BeaconStateError),
+    ParticipationCache(#[allow(dead_code)] ParticipationCacheError),
+    UnableToFindValidator(#[allow(dead_code)] usize),
 }
 
 impl From<BlockReplayError> for AttestationPerformanceError {

beacon_node/http_api/src/block_packing_efficiency.rs

@@ -19,10 +19,11 @@ use warp_utils::reject::{beacon_chain_error, custom_bad_request, custom_server_e
 const BLOCK_ROOT_CHUNK_SIZE: usize = 100;
 
 #[derive(Debug)]
+// We don't use the inner values directly, but they're used in the Debug impl.
 enum PackingEfficiencyError {
-    BlockReplay(BlockReplayError),
-    BeaconState(BeaconStateError),
-    CommitteeStoreError(Slot),
+    BlockReplay(#[allow(dead_code)] BlockReplayError),
+    BeaconState(#[allow(dead_code)] BeaconStateError),
+    CommitteeStoreError(#[allow(dead_code)] Slot),
     InvalidAttestationError,
 }
 

beacon_node/http_api/src/lib.rs

@@ -1019,7 +1019,7 @@ pub fn serve<T: BeaconChainTypes>(
                                 Ok((
                                     state
                                         .get_built_sync_committee(epoch, &chain.spec)
-                                        .map(|committee| committee.clone())
+                                        .cloned()
                                         .map_err(|e| match e {
                                             BeaconStateError::SyncCommitteeNotKnown { .. } => {
                                                 warp_utils::reject::custom_bad_request(format!(
@@ -2858,7 +2858,7 @@ pub fn serve<T: BeaconChainTypes>(
                                 hex::encode(
                                     meta_data
                                         .syncnets()
-                                        .map(|x| x.clone())
+                                        .cloned()
                                         .unwrap_or_default()
                                         .into_bytes()
                                 )

beacon_node/lighthouse_network/src/gossipsub/behaviour/tests.rs

@@ -174,7 +174,7 @@ fn inject_nodes1() -> InjectNodes<IdentityTransform, AllowAllSubscriptionFilter>
 
 fn add_peer<D, F>(
     gs: &mut Behaviour<D, F>,
-    topic_hashes: &Vec<TopicHash>,
+    topic_hashes: &[TopicHash],
     outbound: bool,
     explicit: bool,
 ) -> (PeerId, RpcReceiver)
@@ -187,7 +187,7 @@ where
 
 fn add_peer_with_addr<D, F>(
     gs: &mut Behaviour<D, F>,
-    topic_hashes: &Vec<TopicHash>,
+    topic_hashes: &[TopicHash],
     outbound: bool,
     explicit: bool,
     address: Multiaddr,
@@ -208,7 +208,7 @@ where
 
 fn add_peer_with_addr_and_kind<D, F>(
     gs: &mut Behaviour<D, F>,
-    topic_hashes: &Vec<TopicHash>,
+    topic_hashes: &[TopicHash],
     outbound: bool,
     explicit: bool,
     address: Multiaddr,
@@ -3218,7 +3218,7 @@ fn test_scoring_p1() {
     );
 }
 
-fn random_message(seq: &mut u64, topics: &Vec<TopicHash>) -> RawMessage {
+fn random_message(seq: &mut u64, topics: &[TopicHash]) -> RawMessage {
     let mut rng = rand::thread_rng();
     *seq += 1;
     RawMessage {
@@ -4080,20 +4080,20 @@ fn test_scoring_p6() {
     //create 5 peers with the same ip
     let addr = Multiaddr::from(Ipv4Addr::new(10, 1, 2, 3));
     let peers = vec![
-        add_peer_with_addr(&mut gs, &vec![], false, false, addr.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], false, false, addr.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], true, false, addr.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], true, false, addr.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], true, true, addr.clone()).0,
+        add_peer_with_addr(&mut gs, &[], false, false, addr.clone()).0,
+        add_peer_with_addr(&mut gs, &[], false, false, addr.clone()).0,
+        add_peer_with_addr(&mut gs, &[], true, false, addr.clone()).0,
+        add_peer_with_addr(&mut gs, &[], true, false, addr.clone()).0,
+        add_peer_with_addr(&mut gs, &[], true, true, addr.clone()).0,
     ];
 
     //create 4 other peers with other ip
     let addr2 = Multiaddr::from(Ipv4Addr::new(10, 1, 2, 4));
     let others = vec![
-        add_peer_with_addr(&mut gs, &vec![], false, false, addr2.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], false, false, addr2.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], true, false, addr2.clone()).0,
-        add_peer_with_addr(&mut gs, &vec![], true, false, addr2.clone()).0,
+        add_peer_with_addr(&mut gs, &[], false, false, addr2.clone()).0,
+        add_peer_with_addr(&mut gs, &[], false, false, addr2.clone()).0,
+        add_peer_with_addr(&mut gs, &[], true, false, addr2.clone()).0,
+        add_peer_with_addr(&mut gs, &[], true, false, addr2.clone()).0,
     ];
 
     //no penalties yet

beacon_node/lighthouse_network/tests/common.rs

@@ -42,7 +42,12 @@ pub fn fork_context(fork_name: ForkName) -> ForkContext {
     ForkContext::new::<E>(current_slot, Hash256::zero(), &chain_spec)
 }
 
-pub struct Libp2pInstance(LibP2PService<ReqId, E>, exit_future::Signal);
+pub struct Libp2pInstance(
+    LibP2PService<ReqId, E>,
+    #[allow(dead_code)]
+    // This field is managed for lifetime purposes may not be used directly, hence the `#[allow(dead_code)]` attribute.
+    exit_future::Signal,
+);
 
 impl std::ops::Deref for Libp2pInstance {
     type Target = LibP2PService<ReqId, E>;

beacon_node/network/src/subnet_service/tests/mod.rs

@@ -253,7 +253,7 @@ mod attestation_service {
             &attestation_service.beacon_chain.spec,
         )
         .unwrap();
-        let expected = vec![
+        let expected = [
             SubnetServiceMessage::Subscribe(Subnet::Attestation(subnet_id)),
             SubnetServiceMessage::Unsubscribe(Subnet::Attestation(subnet_id)),
         ];

beacon_node/store/src/hot_cold_store.rs

@@ -1344,7 +1344,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         high_restore_point
             .get_block_root(slot)
             .or_else(|_| high_restore_point.get_oldest_block_root())
-            .map(|x| *x)
+            .copied()
             .map_err(HotColdDBError::RestorePointBlockHashError)
     }