Rust 1.89 compiler lint fix (#7644)

chong-he · web-flow · commit 8e3c5d152413 · 2025-06-25T05:33:17.000Z
Fix lints for Rust 1.89 beta compiler
diff --git a/beacon_node/beacon_chain/src/attestation_verification.rs b/beacon_node/beacon_chain/src/attestation_verification.rs
@@ -353,7 +353,7 @@ impl<T: BeaconChainTypes> Clone for IndexedUnaggregatedAttestation<'_, T> {
 /// A helper trait implemented on wrapper types that can be progressed to a state where they can be
 /// verified for application to fork choice.
 pub trait VerifiedAttestation<T: BeaconChainTypes>: Sized {
-    fn attestation(&self) -> AttestationRef<T::EthSpec>;
+    fn attestation(&self) -> AttestationRef<'_, T::EthSpec>;
 
     fn indexed_attestation(&self) -> &IndexedAttestation<T::EthSpec>;
 
@@ -366,7 +366,7 @@ pub trait VerifiedAttestation<T: BeaconChainTypes>: Sized {
 }
 
 impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedAggregatedAttestation<'_, T> {
-    fn attestation(&self) -> AttestationRef<T::EthSpec> {
+    fn attestation(&self) -> AttestationRef<'_, T::EthSpec> {
         self.attestation()
     }
 
@@ -376,7 +376,7 @@ impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedAggregatedAttestati
 }
 
 impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedUnaggregatedAttestation<'_, T> {
-    fn attestation(&self) -> AttestationRef<T::EthSpec> {
+    fn attestation(&self) -> AttestationRef<'_, T::EthSpec> {
         self.attestation.to_ref()
     }
 
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -7080,7 +7080,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         block_root: Hash256,
         block_data: AvailableBlockData<T::EthSpec>,
-    ) -> Result<Option<StoreOp<T::EthSpec>>, String> {
+    ) -> Result<Option<StoreOp<'_, T::EthSpec>>, String> {
         match block_data {
             AvailableBlockData::NoData => Ok(None),
             AvailableBlockData::Blobs(blobs) => {
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
@@ -2042,7 +2042,7 @@ pub fn cheap_state_advance_to_obtain_committees<'a, E: EthSpec, Err: BlockBlobEr
 /// Obtains a read-locked `ValidatorPubkeyCache` from the `chain`.
 pub fn get_validator_pubkey_cache<T: BeaconChainTypes>(
     chain: &BeaconChain<T>,
-) -> Result<RwLockReadGuard<ValidatorPubkeyCache<T>>, BeaconChainError> {
+) -> Result<RwLockReadGuard<'_, ValidatorPubkeyCache<T>>, BeaconChainError> {
     Ok(chain.validator_pubkey_cache.read())
 }
 
diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs
@@ -365,7 +365,7 @@ pub trait AsBlock<E: EthSpec> {
     fn parent_root(&self) -> Hash256;
     fn state_root(&self) -> Hash256;
     fn signed_block_header(&self) -> SignedBeaconBlockHeader;
-    fn message(&self) -> BeaconBlockRef<E>;
+    fn message(&self) -> BeaconBlockRef<'_, E>;
     fn as_block(&self) -> &SignedBeaconBlock<E>;
     fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>>;
     fn canonical_root(&self) -> Hash256;
@@ -392,7 +392,7 @@ impl<E: EthSpec> AsBlock<E> for Arc<SignedBeaconBlock<E>> {
         SignedBeaconBlock::signed_block_header(self)
     }
 
-    fn message(&self) -> BeaconBlockRef<E> {
+    fn message(&self) -> BeaconBlockRef<'_, E> {
         SignedBeaconBlock::message(self)
     }
 
@@ -425,7 +425,7 @@ impl<E: EthSpec> AsBlock<E> for MaybeAvailableBlock<E> {
     fn signed_block_header(&self) -> SignedBeaconBlockHeader {
         self.as_block().signed_block_header()
     }
-    fn message(&self) -> BeaconBlockRef<E> {
+    fn message(&self) -> BeaconBlockRef<'_, E> {
         self.as_block().message()
     }
     fn as_block(&self) -> &SignedBeaconBlock<E> {
@@ -466,7 +466,7 @@ impl<E: EthSpec> AsBlock<E> for AvailableBlock<E> {
         self.block().signed_block_header()
     }
 
-    fn message(&self) -> BeaconBlockRef<E> {
+    fn message(&self) -> BeaconBlockRef<'_, E> {
         self.block().message()
     }
 
@@ -499,7 +499,7 @@ impl<E: EthSpec> AsBlock<E> for RpcBlock<E> {
     fn signed_block_header(&self) -> SignedBeaconBlockHeader {
         self.as_block().signed_block_header()
     }
-    fn message(&self) -> BeaconBlockRef<E> {
+    fn message(&self) -> BeaconBlockRef<'_, E> {
         self.as_block().message()
     }
     fn as_block(&self) -> &SignedBeaconBlock<E> {
diff --git a/beacon_node/beacon_chain/src/canonical_head.rs b/beacon_node/beacon_chain/src/canonical_head.rs
@@ -73,11 +73,11 @@ impl<T> CanonicalHeadRwLock<T> {
         Self::from(RwLock::new(item))
     }
 
-    fn read(&self) -> RwLockReadGuard<T> {
+    fn read(&self) -> RwLockReadGuard<'_, T> {
         self.0.read()
     }
 
-    fn write(&self) -> RwLockWriteGuard<T> {
+    fn write(&self) -> RwLockWriteGuard<'_, T> {
         self.0.write()
     }
 }
@@ -369,26 +369,26 @@ impl<T: BeaconChainTypes> CanonicalHead<T> {
     ///
     /// This function is **not safe** to be public. See the module-level documentation for more
     /// information about protecting from deadlocks.
-    fn cached_head_read_lock(&self) -> RwLockReadGuard<CachedHead<T::EthSpec>> {
+    fn cached_head_read_lock(&self) -> RwLockReadGuard<'_, CachedHead<T::EthSpec>> {
         self.cached_head.read()
     }
 
     /// Access a write-lock for the cached head.
     ///
     /// This function is **not safe** to be public. See the module-level documentation for more
     /// information about protecting from deadlocks.
-    fn cached_head_write_lock(&self) -> RwLockWriteGuard<CachedHead<T::EthSpec>> {
+    fn cached_head_write_lock(&self) -> RwLockWriteGuard<'_, CachedHead<T::EthSpec>> {
         self.cached_head.write()
     }
 
     /// Access a read-lock for fork choice.
-    pub fn fork_choice_read_lock(&self) -> RwLockReadGuard<BeaconForkChoice<T>> {
+    pub fn fork_choice_read_lock(&self) -> RwLockReadGuard<'_, BeaconForkChoice<T>> {
         let _timer = metrics::start_timer(&metrics::FORK_CHOICE_READ_LOCK_AQUIRE_TIMES);
         self.fork_choice.read()
     }
 
     /// Access a write-lock for fork choice.
-    pub fn fork_choice_write_lock(&self) -> RwLockWriteGuard<BeaconForkChoice<T>> {
+    pub fn fork_choice_write_lock(&self) -> RwLockWriteGuard<'_, BeaconForkChoice<T>> {
         let _timer = metrics::start_timer(&metrics::FORK_CHOICE_WRITE_LOCK_AQUIRE_TIMES);
         self.fork_choice.write()
     }
diff --git a/beacon_node/beacon_chain/src/kzg_utils.rs b/beacon_node/beacon_chain/src/kzg_utils.rs
@@ -25,7 +25,7 @@ fn ssz_blob_to_crypto_blob_boxed<E: EthSpec>(blob: &Blob<E>) -> Result<Box<KzgBl
 
 /// Converts a cell ssz List object to an array to be used with the kzg
 /// crypto library.
-fn ssz_cell_to_crypto_cell<E: EthSpec>(cell: &Cell<E>) -> Result<KzgCellRef, KzgError> {
+fn ssz_cell_to_crypto_cell<E: EthSpec>(cell: &Cell<E>) -> Result<KzgCellRef<'_>, KzgError> {
     let cell_bytes: &[u8] = cell.as_ref();
     Ok(cell_bytes
         .try_into()
diff --git a/beacon_node/execution_layer/src/engine_api.rs b/beacon_node/execution_layer/src/engine_api.rs
@@ -380,7 +380,7 @@ pub enum GetPayloadResponseType<E: EthSpec> {
 }
 
 impl<E: EthSpec> GetPayloadResponse<E> {
-    pub fn execution_payload_ref(&self) -> ExecutionPayloadRef<E> {
+    pub fn execution_payload_ref(&self) -> ExecutionPayloadRef<'_, E> {
         self.to_ref().into()
     }
 }
diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
@@ -67,7 +67,7 @@ struct VerifiedUnaggregate<T: BeaconChainTypes> {
 /// This implementation allows `Self` to be imported to fork choice and other functions on the
 /// `BeaconChain`.
 impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedUnaggregate<T> {
-    fn attestation(&self) -> AttestationRef<T::EthSpec> {
+    fn attestation(&self) -> AttestationRef<'_, T::EthSpec> {
         self.attestation.to_ref()
     }
 
@@ -100,7 +100,7 @@ struct VerifiedAggregate<T: BeaconChainTypes> {
 /// This implementation allows `Self` to be imported to fork choice and other functions on the
 /// `BeaconChain`.
 impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedAggregate<T> {
-    fn attestation(&self) -> AttestationRef<T::EthSpec> {
+    fn attestation(&self) -> AttestationRef<'_, T::EthSpec> {
         self.signed_aggregate.message().aggregate()
     }
 
diff --git a/beacon_node/operation_pool/src/attestation_storage.rs b/beacon_node/operation_pool/src/attestation_storage.rs
@@ -96,7 +96,7 @@ impl<E: EthSpec> SplitAttestation<E> {
         }
     }
 
-    pub fn as_ref(&self) -> CompactAttestationRef<E> {
+    pub fn as_ref(&self) -> CompactAttestationRef<'_, E> {
         CompactAttestationRef {
             checkpoint: &self.checkpoint,
             data: &self.data,
@@ -438,7 +438,7 @@ impl<E: EthSpec> AttestationMap<E> {
     }
 
     /// Iterate all attestations in the map.
-    pub fn iter(&self) -> impl Iterator<Item = CompactAttestationRef<E>> {
+    pub fn iter(&self) -> impl Iterator<Item = CompactAttestationRef<'_, E>> {
         self.checkpoint_map
             .iter()
             .flat_map(|(checkpoint_key, attestation_map)| attestation_map.iter(checkpoint_key))
diff --git a/beacon_node/store/src/database/interface.rs b/beacon_node/store/src/database/interface.rs
@@ -114,7 +114,11 @@ impl<E: EthSpec> KeyValueStore<E> for BeaconNodeBackend<E> {
         }
     }
 
-    fn iter_column_keys_from<K: Key>(&self, _column: DBColumn, from: &[u8]) -> ColumnKeyIter<K> {
+    fn iter_column_keys_from<K: Key>(
+        &self,
+        _column: DBColumn,
+        from: &[u8],
+    ) -> ColumnKeyIter<'_, K> {
         match self {
             #[cfg(feature = "leveldb")]
             BeaconNodeBackend::LevelDb(txn) => {
@@ -127,7 +131,7 @@ impl<E: EthSpec> KeyValueStore<E> for BeaconNodeBackend<E> {
         }
     }
 
-    fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<K> {
+    fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<'_, K> {
         match self {
             #[cfg(feature = "leveldb")]
             BeaconNodeBackend::LevelDb(txn) => leveldb_impl::LevelDB::iter_column_keys(txn, column),
@@ -136,7 +140,7 @@ impl<E: EthSpec> KeyValueStore<E> for BeaconNodeBackend<E> {
         }
     }
 
-    fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<K> {
+    fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<'_, K> {
         match self {
             #[cfg(feature = "leveldb")]
             BeaconNodeBackend::LevelDb(txn) => {
diff --git a/beacon_node/store/src/database/leveldb_impl.rs b/beacon_node/store/src/database/leveldb_impl.rs
@@ -47,7 +47,7 @@ impl<E: EthSpec> LevelDB<E> {
         })
     }
 
-    pub fn read_options(&self) -> ReadOptions<BytesKey> {
+    pub fn read_options(&self) -> ReadOptions<'_, BytesKey> {
         ReadOptions::new()
     }
 
@@ -207,7 +207,7 @@ impl<E: EthSpec> LevelDB<E> {
         Ok(())
     }
 
-    pub fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<K> {
+    pub fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<'_, K> {
         let start_key = BytesKey::from_vec(get_key_for_col(column, from));
         let iter = self.db.iter(self.read_options());
         iter.seek(&start_key);
@@ -231,7 +231,11 @@ impl<E: EthSpec> LevelDB<E> {
         )
     }
 
-    pub fn iter_column_keys_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnKeyIter<K> {
+    pub fn iter_column_keys_from<K: Key>(
+        &self,
+        column: DBColumn,
+        from: &[u8],
+    ) -> ColumnKeyIter<'_, K> {
         let start_key = BytesKey::from_vec(get_key_for_col(column, from));
 
         let iter = self.db.keys_iter(self.read_options());
@@ -253,11 +257,11 @@ impl<E: EthSpec> LevelDB<E> {
     }
 
     /// Iterate through all keys and values in a particular column.
-    pub fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<K> {
+    pub fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<'_, K> {
         self.iter_column_keys_from(column, &vec![0; column.key_size()])
     }
 
-    pub fn iter_column<K: Key>(&self, column: DBColumn) -> ColumnIter<K> {
+    pub fn iter_column<K: Key>(&self, column: DBColumn) -> ColumnIter<'_, K> {
         self.iter_column_from(column, &vec![0; column.key_size()])
     }
 
diff --git a/beacon_node/store/src/hot_cold_store.rs b/beacon_node/store/src/hot_cold_store.rs
@@ -1125,7 +1125,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         start_slot: Slot,
         end_slot: Slot,
         get_state: impl FnOnce() -> Result<(BeaconState<E>, Hash256), Error>,
-    ) -> Result<HybridForwardsBlockRootsIterator<E, Hot, Cold>, Error> {
+    ) -> Result<HybridForwardsBlockRootsIterator<'_, E, Hot, Cold>, Error> {
         HybridForwardsBlockRootsIterator::new(
             self,
             DBColumn::BeaconBlockRoots,
@@ -1155,7 +1155,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         start_slot: Slot,
         end_slot: Slot,
         get_state: impl FnOnce() -> Result<(BeaconState<E>, Hash256), Error>,
-    ) -> Result<HybridForwardsStateRootsIterator<E, Hot, Cold>, Error> {
+    ) -> Result<HybridForwardsStateRootsIterator<'_, E, Hot, Cold>, Error> {
         HybridForwardsStateRootsIterator::new(
             self,
             DBColumn::BeaconStateRoots,
diff --git a/beacon_node/store/src/lib.rs b/beacon_node/store/src/lib.rs
@@ -92,17 +92,17 @@ pub trait KeyValueStore<E: EthSpec>: Sync + Send + Sized + 'static {
     }
 
     /// Iterate through all keys and values in a particular column.
-    fn iter_column<K: Key>(&self, column: DBColumn) -> ColumnIter<K> {
+    fn iter_column<K: Key>(&self, column: DBColumn) -> ColumnIter<'_, K> {
         self.iter_column_from(column, &vec![0; column.key_size()])
     }
 
     /// Iterate through all keys and values in a column from a given starting point that fulfill the given predicate.
-    fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<K>;
+    fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<'_, K>;
 
-    fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<K>;
+    fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<'_, K>;
 
     /// Iterate through all keys in a particular column.
-    fn iter_column_keys_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnKeyIter<K>;
+    fn iter_column_keys_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnKeyIter<'_, K>;
 
     fn delete_batch(&self, column: DBColumn, ops: HashSet<&[u8]>) -> Result<(), Error>;
 
diff --git a/beacon_node/store/src/memory_store.rs b/beacon_node/store/src/memory_store.rs
@@ -80,7 +80,7 @@ impl<E: EthSpec> KeyValueStore<E> for MemoryStore<E> {
         Ok(())
     }
 
-    fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<K> {
+    fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<'_, K> {
         // We use this awkward pattern because we can't lock the `self.db` field *and* maintain a
         // reference to the lock guard across calls to `.next()`. This would be require a
         // struct with a field (the iterator) which references another field (the lock guard).
@@ -101,15 +101,15 @@ impl<E: EthSpec> KeyValueStore<E> for MemoryStore<E> {
         }))
     }
 
-    fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<K> {
+    fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<'_, K> {
         Box::new(self.iter_column(column).map(|res| res.map(|(k, _)| k)))
     }
 
     fn compact_column(&self, _column: DBColumn) -> Result<(), Error> {
         Ok(())
     }
 
-    fn iter_column_keys_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnKeyIter<K> {
+    fn iter_column_keys_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnKeyIter<'_, K> {
         // We use this awkward pattern because we can't lock the `self.db` field *and* maintain a
         // reference to the lock guard across calls to `.next()`. This would be require a
         // struct with a field (the iterator) which references another field (the lock guard).
diff --git a/consensus/proto_array/src/proto_array_fork_choice.rs b/consensus/proto_array/src/proto_array_fork_choice.rs
@@ -856,7 +856,7 @@ impl ProtoArrayForkChoice {
     }
 
     /// See `ProtoArray::iter_nodes`
-    pub fn iter_nodes(&self, block_root: &Hash256) -> Iter {
+    pub fn iter_nodes(&self, block_root: &Hash256) -> Iter<'_> {
         self.proto_array.iter_nodes(block_root)
     }
 
diff --git a/consensus/state_processing/src/consensus_context.rs b/consensus/state_processing/src/consensus_context.rs
@@ -148,12 +148,12 @@ impl<E: EthSpec> ConsensusContext<E> {
     }
 
     #[allow(unknown_lints)]
-    #[allow(elided_named_lifetimes)]
+    #[allow(mismatched_lifetime_syntaxes)]
     pub fn get_indexed_attestation<'a>(
         &'a mut self,
         state: &BeaconState<E>,
         attestation: AttestationRef<'a, E>,
-    ) -> Result<IndexedAttestationRef<E>, BlockOperationError<AttestationInvalid>> {
+    ) -> Result<IndexedAttestationRef<'a, E>, BlockOperationError<AttestationInvalid>> {
         let key = attestation.tree_hash_root();
         match attestation {
             AttestationRef::Base(attn) => match self.indexed_attestations.entry(key) {
diff --git a/consensus/state_processing/src/per_block_processing/signature_sets.rs b/consensus/state_processing/src/per_block_processing/signature_sets.rs
@@ -56,7 +56,7 @@ impl From<BeaconStateError> for Error {
 pub fn get_pubkey_from_state<E>(
     state: &BeaconState<E>,
     validator_index: usize,
-) -> Option<Cow<PublicKey>>
+) -> Option<Cow<'_, PublicKey>>
 where
     E: EthSpec,
 {
diff --git a/consensus/types/src/attestation.rs b/consensus/types/src/attestation.rs
@@ -511,7 +511,7 @@ pub enum AttestationOnDisk<E: EthSpec> {
 }
 
 impl<E: EthSpec> AttestationOnDisk<E> {
-    pub fn to_ref(&self) -> AttestationRefOnDisk<E> {
+    pub fn to_ref(&self) -> AttestationRefOnDisk<'_, E> {
         match self {
             AttestationOnDisk::Base(att) => AttestationRefOnDisk::Base(att),
             AttestationOnDisk::Electra(att) => AttestationRefOnDisk::Electra(att),
diff --git a/consensus/types/src/attester_slashing.rs b/consensus/types/src/attester_slashing.rs
@@ -141,7 +141,7 @@ impl<'a, E: EthSpec> AttesterSlashingRef<'a, E> {
 }
 
 impl<E: EthSpec> AttesterSlashing<E> {
-    pub fn attestation_1(&self) -> IndexedAttestationRef<E> {
+    pub fn attestation_1(&self) -> IndexedAttestationRef<'_, E> {
         match self {
             AttesterSlashing::Base(attester_slashing) => {
                 IndexedAttestationRef::Base(&attester_slashing.attestation_1)
@@ -152,7 +152,7 @@ impl<E: EthSpec> AttesterSlashing<E> {
         }
     }
 
-    pub fn attestation_2(&self) -> IndexedAttestationRef<E> {
+    pub fn attestation_2(&self) -> IndexedAttestationRef<'_, E> {
         match self {
             AttesterSlashing::Base(attester_slashing) => {
                 IndexedAttestationRef::Base(&attester_slashing.attestation_2)
diff --git a/consensus/types/src/beacon_state.rs b/consensus/types/src/beacon_state.rs
diff --git a/consensus/types/src/beacon_state/committee_cache.rs b/consensus/types/src/beacon_state/committee_cache.rs
diff --git a/consensus/types/src/slot_epoch.rs b/consensus/types/src/slot_epoch.rs
diff --git a/consensus/types/src/sqlite.rs b/consensus/types/src/sqlite.rs
diff --git a/slasher/src/array.rs b/slasher/src/array.rs
diff --git a/slasher/src/database.rs b/slasher/src/database.rs
diff --git a/slasher/src/database/interface.rs b/slasher/src/database/interface.rs
diff --git a/slasher/src/database/lmdb_impl.rs b/slasher/src/database/lmdb_impl.rs
diff --git a/validator_client/initialized_validators/src/lib.rs b/validator_client/initialized_validators/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -353,7 +353,7 @@ impl<T: BeaconChainTypes> Clone for IndexedUnaggregatedAttestation<'_, T> {`
`353`	`353`	`/// A helper trait implemented on wrapper types that can be progressed to a state where they can be`
`354`	`354`	`/// verified for application to fork choice.`
`355`	`355`	`pub trait VerifiedAttestation<T: BeaconChainTypes>: Sized {`
`356`		`- fn attestation(&self) -> AttestationRef<T::EthSpec>;`
	`356`	`+ fn attestation(&self) -> AttestationRef<'_, T::EthSpec>;`
`357`	`357`
`358`	`358`	`fn indexed_attestation(&self) -> &IndexedAttestation<T::EthSpec>;`
`359`	`359`
`@@ -366,7 +366,7 @@ pub trait VerifiedAttestation<T: BeaconChainTypes>: Sized {`
`366`	`366`	`}`
`367`	`367`
`368`	`368`	`impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedAggregatedAttestation<'_, T> {`
`369`		`- fn attestation(&self) -> AttestationRef<T::EthSpec> {`
	`369`	`+ fn attestation(&self) -> AttestationRef<'_, T::EthSpec> {`
`370`	`370`	`self.attestation()`
`371`	`371`	`}`
`372`	`372`
`@@ -376,7 +376,7 @@ impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedAggregatedAttestati`
`376`	`376`	`}`
`377`	`377`
`378`	`378`	`impl<T: BeaconChainTypes> VerifiedAttestation<T> for VerifiedUnaggregatedAttestation<'_, T> {`
`379`		`- fn attestation(&self) -> AttestationRef<T::EthSpec> {`
	`379`	`+ fn attestation(&self) -> AttestationRef<'_, T::EthSpec> {`
`380`	`380`	`self.attestation.to_ref()`
`381`	`381`	`}`
`382`	`382`
Original file line number	Diff line number	Diff line change
`@@ -2042,7 +2042,7 @@ pub fn cheap_state_advance_to_obtain_committees<'a, E: EthSpec, Err: BlockBlobEr`
`2042`	`2042`	/// Obtains a read-locked `ValidatorPubkeyCache` from the `chain`.
`2043`	`2043`	`pub fn get_validator_pubkey_cache<T: BeaconChainTypes>(`
`2044`	`2044`	`chain: &BeaconChain<T>,`
`2045`		`-) -> Result<RwLockReadGuard<ValidatorPubkeyCache<T>>, BeaconChainError> {`
	`2045`	`+) -> Result<RwLockReadGuard<'_, ValidatorPubkeyCache<T>>, BeaconChainError> {`
`2046`	`2046`	`Ok(chain.validator_pubkey_cache.read())`
`2047`	`2047`	`}`
`2048`	`2048`
Original file line number	Diff line number	Diff line change
`@@ -365,7 +365,7 @@ pub trait AsBlock<E: EthSpec> {`
`365`	`365`	`fn parent_root(&self) -> Hash256;`
`366`	`366`	`fn state_root(&self) -> Hash256;`
`367`	`367`	`fn signed_block_header(&self) -> SignedBeaconBlockHeader;`
`368`		`- fn message(&self) -> BeaconBlockRef<E>;`
	`368`	`+ fn message(&self) -> BeaconBlockRef<'_, E>;`
`369`	`369`	`fn as_block(&self) -> &SignedBeaconBlock<E>;`
`370`	`370`	`fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>>;`
`371`	`371`	`fn canonical_root(&self) -> Hash256;`
`@@ -392,7 +392,7 @@ impl<E: EthSpec> AsBlock<E> for Arc<SignedBeaconBlock<E>> {`
`392`	`392`	`SignedBeaconBlock::signed_block_header(self)`
`393`	`393`	`}`
`394`	`394`
`395`		`- fn message(&self) -> BeaconBlockRef<E> {`
	`395`	`+ fn message(&self) -> BeaconBlockRef<'_, E> {`
`396`	`396`	`SignedBeaconBlock::message(self)`
`397`	`397`	`}`
`398`	`398`
`@@ -425,7 +425,7 @@ impl<E: EthSpec> AsBlock<E> for MaybeAvailableBlock<E> {`
`425`	`425`	`fn signed_block_header(&self) -> SignedBeaconBlockHeader {`
`426`	`426`	`self.as_block().signed_block_header()`
`427`	`427`	`}`
`428`		`- fn message(&self) -> BeaconBlockRef<E> {`
	`428`	`+ fn message(&self) -> BeaconBlockRef<'_, E> {`
`429`	`429`	`self.as_block().message()`
`430`	`430`	`}`
`431`	`431`	`fn as_block(&self) -> &SignedBeaconBlock<E> {`
`@@ -466,7 +466,7 @@ impl<E: EthSpec> AsBlock<E> for AvailableBlock<E> {`
`466`	`466`	`self.block().signed_block_header()`
`467`	`467`	`}`
`468`	`468`
`469`		`- fn message(&self) -> BeaconBlockRef<E> {`
	`469`	`+ fn message(&self) -> BeaconBlockRef<'_, E> {`
`470`	`470`	`self.block().message()`
`471`	`471`	`}`
`472`	`472`
`@@ -499,7 +499,7 @@ impl<E: EthSpec> AsBlock<E> for RpcBlock<E> {`
`499`	`499`	`fn signed_block_header(&self) -> SignedBeaconBlockHeader {`
`500`	`500`	`self.as_block().signed_block_header()`
`501`	`501`	`}`
`502`		`- fn message(&self) -> BeaconBlockRef<E> {`
	`502`	`+ fn message(&self) -> BeaconBlockRef<'_, E> {`
`503`	`503`	`self.as_block().message()`
`504`	`504`	`}`
`505`	`505`	`fn as_block(&self) -> &SignedBeaconBlock<E> {`
Original file line number	Diff line number	Diff line change
`@@ -73,11 +73,11 @@ impl<T> CanonicalHeadRwLock<T> {`
`73`	`73`	`Self::from(RwLock::new(item))`
`74`	`74`	`}`
`75`	`75`
`76`		`- fn read(&self) -> RwLockReadGuard<T> {`
	`76`	`+ fn read(&self) -> RwLockReadGuard<'_, T> {`
`77`	`77`	`self.0.read()`
`78`	`78`	`}`
`79`	`79`
`80`		`- fn write(&self) -> RwLockWriteGuard<T> {`
	`80`	`+ fn write(&self) -> RwLockWriteGuard<'_, T> {`
`81`	`81`	`self.0.write()`
`82`	`82`	`}`
`83`	`83`	`}`
`@@ -369,26 +369,26 @@ impl<T: BeaconChainTypes> CanonicalHead<T> {`
`369`	`369`	`///`
`370`	`370`	`/// This function is not safe to be public. See the module-level documentation for more`
`371`	`371`	`/// information about protecting from deadlocks.`
`372`		`- fn cached_head_read_lock(&self) -> RwLockReadGuard<CachedHead<T::EthSpec>> {`
	`372`	`+ fn cached_head_read_lock(&self) -> RwLockReadGuard<'_, CachedHead<T::EthSpec>> {`
`373`	`373`	`self.cached_head.read()`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`/// Access a write-lock for the cached head.`
`377`	`377`	`///`
`378`	`378`	`/// This function is not safe to be public. See the module-level documentation for more`
`379`	`379`	`/// information about protecting from deadlocks.`
`380`		`- fn cached_head_write_lock(&self) -> RwLockWriteGuard<CachedHead<T::EthSpec>> {`
	`380`	`+ fn cached_head_write_lock(&self) -> RwLockWriteGuard<'_, CachedHead<T::EthSpec>> {`
`381`	`381`	`self.cached_head.write()`
`382`	`382`	`}`
`383`	`383`
`384`	`384`	`/// Access a read-lock for fork choice.`
`385`		`- pub fn fork_choice_read_lock(&self) -> RwLockReadGuard<BeaconForkChoice<T>> {`
	`385`	`+ pub fn fork_choice_read_lock(&self) -> RwLockReadGuard<'_, BeaconForkChoice<T>> {`
`386`	`386`	`let _timer = metrics::start_timer(&metrics::FORK_CHOICE_READ_LOCK_AQUIRE_TIMES);`
`387`	`387`	`self.fork_choice.read()`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`/// Access a write-lock for fork choice.`
`391`		`- pub fn fork_choice_write_lock(&self) -> RwLockWriteGuard<BeaconForkChoice<T>> {`
	`391`	`+ pub fn fork_choice_write_lock(&self) -> RwLockWriteGuard<'_, BeaconForkChoice<T>> {`
`392`	`392`	`let _timer = metrics::start_timer(&metrics::FORK_CHOICE_WRITE_LOCK_AQUIRE_TIMES);`
`393`	`393`	`self.fork_choice.write()`
`394`	`394`	`}`
Original file line number	Diff line number	Diff line change
`@@ -380,7 +380,7 @@ pub enum GetPayloadResponseType<E: EthSpec> {`
`380`	`380`	`}`
`381`	`381`
`382`	`382`	`impl<E: EthSpec> GetPayloadResponse<E> {`
`383`		`- pub fn execution_payload_ref(&self) -> ExecutionPayloadRef<E> {`
	`383`	`+ pub fn execution_payload_ref(&self) -> ExecutionPayloadRef<'_, E> {`
`384`	`384`	`self.to_ref().into()`
`385`	`385`	`}`
`386`	`386`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ impl<E: EthSpec> SplitAttestation<E> {`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`99`		`- pub fn as_ref(&self) -> CompactAttestationRef<E> {`
	`99`	`+ pub fn as_ref(&self) -> CompactAttestationRef<'_, E> {`
`100`	`100`	`CompactAttestationRef {`
`101`	`101`	`checkpoint: &self.checkpoint,`
`102`	`102`	`data: &self.data,`
`@@ -438,7 +438,7 @@ impl<E: EthSpec> AttestationMap<E> {`
`438`	`438`	`}`
`439`	`439`
`440`	`440`	`/// Iterate all attestations in the map.`
`441`		`- pub fn iter(&self) -> impl Iterator<Item = CompactAttestationRef<E>> {`
	`441`	`+ pub fn iter(&self) -> impl Iterator<Item = CompactAttestationRef<'_, E>> {`
`442`	`442`	`self.checkpoint_map`
`443`	`443`	`.iter()`
`444`	`444`	`.flat_map(\|(checkpoint_key, attestation_map)\| attestation_map.iter(checkpoint_key))`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,11 @@ impl<E: EthSpec> KeyValueStore<E> for BeaconNodeBackend<E> {`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`- fn iter_column_keys_from<K: Key>(&self, _column: DBColumn, from: &[u8]) -> ColumnKeyIter<K> {`
	`117`	`+ fn iter_column_keys_from<K: Key>(`
	`118`	`+ &self,`
	`119`	`+ _column: DBColumn,`
	`120`	`+ from: &[u8],`
	`121`	`+ ) -> ColumnKeyIter<'_, K> {`
`118`	`122`	`match self {`
`119`	`123`	`#[cfg(feature = "leveldb")]`
`120`	`124`	`BeaconNodeBackend::LevelDb(txn) => {`
`@@ -127,7 +131,7 @@ impl<E: EthSpec> KeyValueStore<E> for BeaconNodeBackend<E> {`
`127`	`131`	`}`
`128`	`132`	`}`
`129`	`133`
`130`		`- fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<K> {`
	`134`	`+ fn iter_column_keys<K: Key>(&self, column: DBColumn) -> ColumnKeyIter<'_, K> {`
`131`	`135`	`match self {`
`132`	`136`	`#[cfg(feature = "leveldb")]`
`133`	`137`	`BeaconNodeBackend::LevelDb(txn) => leveldb_impl::LevelDB::iter_column_keys(txn, column),`
`@@ -136,7 +140,7 @@ impl<E: EthSpec> KeyValueStore<E> for BeaconNodeBackend<E> {`
`136`	`140`	`}`
`137`	`141`	`}`
`138`	`142`
`139`		`- fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<K> {`
	`143`	`+ fn iter_column_from<K: Key>(&self, column: DBColumn, from: &[u8]) -> ColumnIter<'_, K> {`
`140`	`144`	`match self {`
`141`	`145`	`#[cfg(feature = "leveldb")]`
`142`	`146`	`BeaconNodeBackend::LevelDb(txn) => {`