changed possible #[allow()] -> #[expect()] (paradigmxyz#15168)

Co-authored-by: Matthias Seitz <[email protected]>

Author: Rimeeeeee

bin/reth/src/cli/mod.rs

@@ -235,7 +235,7 @@ impl<C: ChainSpecParser<ChainSpec = ChainSpec>, Ext: clap::Args + fmt::Debug> Cl
 
 /// Commands to be executed
 #[derive(Debug, Subcommand)]
-#[allow(clippy::large_enum_variant)]
+#[expect(clippy::large_enum_variant)]
 pub enum Commands<C: ChainSpecParser, Ext: clap::Args + fmt::Debug> {
     /// Start the node
     #[command(name = "node")]

book/sources/exex/hello-world/src/bin/2.rs

@@ -3,7 +3,7 @@ use reth_exex::ExExContext;
 use reth_node_ethereum::EthereumNode;
 
 async fn my_exex<Node: FullNodeComponents>(mut _ctx: ExExContext<Node>) -> eyre::Result<()> {
-    #[allow(clippy::empty_loop)]
+    #[expect(clippy::empty_loop)]
     loop {}
 }
 

book/sources/exex/remote/src/exex_2.rs

@@ -9,7 +9,7 @@ use tokio::sync::{broadcast, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{transport::Server, Request, Response, Status};
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 struct ExExService {
     notifications: Arc<broadcast::Sender<ExExNotification>>,
 }

book/sources/exex/remote/src/exex_4.rs

@@ -46,7 +46,7 @@ impl RemoteExEx for ExExService {
 }
 
 // ANCHOR: snippet
-#[allow(dead_code)]
+#[expect(dead_code)]
 async fn remote_exex<Node: FullNodeComponents<Types: NodeTypes<Primitives = EthPrimitives>>>(
     mut ctx: ExExContext<Node>,
     notifications: Arc<broadcast::Sender<ExExNotification>>,

crates/chain-state/src/memory_overlay.rs

@@ -16,7 +16,7 @@ use std::sync::OnceLock;
 
 /// A state provider that stores references to in-memory blocks along with their state as well as a
 /// reference of the historical state provider for fallback lookups.
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct MemoryOverlayStateProviderRef<
     'a,
     N: NodePrimitives = reth_ethereum_primitives::EthPrimitives,

crates/cli/commands/src/db/diff.rs

@@ -242,11 +242,11 @@ struct TableDiffElement<T: Table> {
     key: T::Key,
 
     /// The element from the first table
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     first: T::Value,
 
     /// The element from the second table
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     second: T::Value,
 }
 
@@ -333,11 +333,11 @@ where
 #[derive(Debug)]
 enum ExtraTableElement<T: Table> {
     /// The extra element that is in the first table
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     First { key: T::Key, value: T::Value },
 
     /// The extra element that is in the second table
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     Second { key: T::Key, value: T::Value },
 }
 

crates/e2e-test-utils/src/rpc.rs

@@ -11,7 +11,7 @@ use reth_rpc_eth_api::{
     EthApiTypes,
 };
 
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct RpcTestContext<Node: FullNodeComponents, EthApi: EthApiTypes> {
     pub inner: RpcRegistry<Node, EthApi>,
 }

crates/e2e-test-utils/src/testsuite/actions.rs

@@ -22,7 +22,7 @@ pub trait Action<I>: Send + 'static {
 }
 
 /// Simplified action container for storage in tests
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct ActionBox<I>(Box<dyn Action<I>>);
 
 impl<I: 'static> ActionBox<I> {
@@ -262,7 +262,7 @@ where
 }
 
 /// Run a sequence of actions in series.
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct Sequence<I> {
     /// Actions to execute in sequence
     pub actions: Vec<Box<dyn Action<I>>>,

crates/e2e-test-utils/src/testsuite/mod.rs

@@ -60,7 +60,7 @@ impl<I> Default for Environment<I> {
 }
 
 /// Builder for creating test scenarios
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 #[derive(Default)]
 pub struct TestBuilder<I> {
     setup: Option<Setup<I>>,

crates/engine/local/src/service.rs

@@ -64,7 +64,7 @@ where
     N: EngineNodeTypes,
 {
     /// Constructor for [`LocalEngineService`].
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     pub fn new<B, V, C>(
         consensus: Arc<dyn FullConsensus<N::Primitives, Error = ConsensusError>>,
         executor_factory: impl BlockExecutorProvider<Primitives = N::Primitives>,

crates/engine/primitives/src/forkchoice.rs

@@ -45,13 +45,13 @@ impl ForkchoiceStateTracker {
     }
 
     /// Returns whether the latest received FCU is valid: [`ForkchoiceStatus::Valid`]
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub(crate) fn is_latest_valid(&self) -> bool {
         self.latest_status().is_some_and(|s| s.is_valid())
     }
 
     /// Returns whether the latest received FCU is syncing: [`ForkchoiceStatus::Syncing`]
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub(crate) fn is_latest_syncing(&self) -> bool {
         self.latest_status().is_some_and(|s| s.is_syncing())
     }

crates/engine/service/src/service.rs

@@ -51,7 +51,7 @@ type EngineServiceType<N, Client> = ChainOrchestrator<
 
 /// The type that drives the chain forward and communicates progress.
 #[pin_project]
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 // TODO(mattsse): remove hidde once fixed : <https://github.com/rust-lang/rust/issues/135363>
 //  otherwise rustdoc fails to resolve the alias
 #[doc(hidden)]
@@ -72,7 +72,7 @@ where
     E: BlockExecutorProvider<Primitives = N::Primitives> + 'static,
 {
     /// Constructor for `EngineService`.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
     pub fn new<V, C>(
         consensus: Arc<dyn FullConsensus<N::Primitives, Error = ConsensusError>>,
         executor_factory: E,

crates/engine/tree/src/backfill.rs

@@ -99,7 +99,7 @@ impl<N: ProviderNodeTypes> PipelineSync<N> {
     }
 
     /// Returns `true` if a pipeline target is queued and will be triggered on the next `poll`.
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     const fn is_pipeline_sync_pending(&self) -> bool {
         self.pending_pipeline_target.is_some() && self.pipeline_state.is_idle()
     }
@@ -212,7 +212,7 @@ impl<N: ProviderNodeTypes> BackfillSync for PipelineSync<N> {
 /// blockchain tree any messages that would result in database writes, since it would result in a
 /// deadlock.
 #[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
+#[expect(clippy::large_enum_variant)]
 enum PipelineState<N: ProviderNodeTypes> {
     /// Pipeline is idle.
     Idle(Option<Pipeline<N>>),

crates/engine/tree/src/download.rs

@@ -55,7 +55,7 @@ pub enum DownloadOutcome<B: Block> {
 }
 
 /// Basic [`BlockDownloader`].
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct BasicBlockDownloader<Client, B: Block>
 where
     Client: BlockClient + 'static,

crates/engine/tree/src/tree/mod.rs

@@ -72,7 +72,7 @@ mod metrics;
 mod payload_processor;
 mod persistence_state;
 // TODO(alexey): compare trie updates in `insert_block_inner`
-#[allow(unused)]
+#[expect(unused)]
 mod trie_updates;
 
 use crate::tree::error::AdvancePersistenceError;
@@ -3126,7 +3126,7 @@ mod tests {
         }
 
         /// Signals to the channel task that a value should be released
-        #[allow(dead_code)]
+        #[expect(dead_code)]
         fn release(&self) {
             let _ = self.release.send(());
         }

crates/engine/tree/src/tree/payload_processor/mod.rs

@@ -400,7 +400,7 @@ impl ExecutionCache {
     }
 
     /// Clears the tracked cache
-    #[allow(unused)]
+    #[expect(unused)]
     pub(crate) fn clear(&self) {
         self.inner.write().take();
     }

crates/engine/tree/src/tree/payload_processor/sparse_trie.rs

@@ -26,7 +26,7 @@ const SPARSE_TRIE_INCREMENTAL_LEVEL: usize = 2;
 /// A task responsible for populating the sparse trie.
 pub(super) struct SparseTrieTask<BPF> {
     /// Executor used to spawn subtasks.
-    #[allow(unused)] // TODO use this for spawning trie tasks
+    #[expect(unused)] // TODO use this for spawning trie tasks
     pub(super) executor: WorkloadExecutor,
     /// Receives updates from the state root task.
     pub(super) updates: mpsc::Receiver<SparseTrieUpdate>,

crates/engine/tree/src/tree/trie_updates.rs

@@ -162,7 +162,7 @@ pub(super) fn compare_trie_updates(
         let (mut task, mut regular) =
             (task.storage_tries.remove(&key), regular.storage_tries.remove(&key));
         if task != regular {
-            #[allow(clippy::or_fun_call)]
+            #[expect(clippy::or_fun_call)]
             let storage_diff = compare_storage_trie_updates(
                 || trie_cursor_factory.storage_trie_cursor(key),
                 // Compare non-existent storage tries as empty.

crates/ethereum/primitives/src/transaction.rs

@@ -967,7 +967,7 @@ pub(super) mod serde_bincode_compat {
     /// Bincode-compatible [`super::Transaction`] serde implementation.
     #[derive(Debug)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-    #[allow(missing_docs)]
+    #[expect(missing_docs)]
     pub enum Transaction<'a> {
         Legacy(TxLegacy<'a>),
         Eip2930(TxEip2930<'a>),

crates/evm/execution-types/src/chain.rs

@@ -498,7 +498,7 @@ impl From<BlockHash> for ChainSplitTarget {
 
 /// Result of a split chain.
 #[derive(Clone, Debug, PartialEq, Eq)]
-#[allow(clippy::large_enum_variant)]
+#[expect(clippy::large_enum_variant)]
 pub enum ChainSplit<N: NodePrimitives = reth_ethereum_primitives::EthPrimitives> {
     /// Chain is not split. Pending chain is returned.
     /// Given block split is higher than last block.

crates/evm/execution-types/src/execution_outcome.rs

@@ -436,7 +436,7 @@ pub(super) mod serde_bincode_compat {
         bundle: Cow<'a, BundleState>,
         receipts: Vec<Vec<T::BincodeRepr<'a>>>,
         first_block: BlockNumber,
-        #[allow(clippy::owned_cow)]
+        #[expect(clippy::owned_cow)]
         requests: Cow<'a, Vec<Requests>>,
     }
 

crates/evm/src/execute.rs

@@ -370,7 +370,7 @@ where
 }
 
 /// A generic block executor provider that can create executors using a strategy factory.
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct BasicBlockExecutorProvider<F> {
     strategy_factory: F,
 }

crates/exex/exex/src/context.rs

@@ -150,7 +150,7 @@ mod tests {
     /// <https://github.com/paradigmxyz/reth/issues/12054>
     #[test]
     const fn issue_12054() {
-        #[allow(dead_code)]
+        #[expect(dead_code)]
         struct ExEx<Node: FullNodeComponents> {
             ctx: ExExContext<Node>,
         }

crates/exex/exex/src/notifications.rs

@@ -64,7 +64,7 @@ pub trait ExExNotificationsStream<N: NodePrimitives = EthPrimitives>:
 }
 
 #[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
+#[expect(clippy::large_enum_variant)]
 enum ExExNotificationsInner<P, E>
 where
     E: BlockExecutorProvider,

crates/exex/types/src/notification.rs

@@ -96,9 +96,9 @@ pub(super) mod serde_bincode_compat {
     /// }
     /// ```
     #[derive(Debug, Serialize, Deserialize)]
-    #[allow(missing_docs)]
+    #[expect(missing_docs)]
     #[serde(bound = "")]
-    #[allow(clippy::large_enum_variant)]
+    #[expect(clippy::large_enum_variant)]
     pub enum ExExNotification<'a, N>
     where
         N: NodePrimitives,

crates/net/discv5/src/lib.rs

@@ -225,7 +225,7 @@ impl Discv5 {
 
     /// Process an event from the underlying [`discv5::Discv5`] node.
     pub fn on_discv5_update(&self, update: discv5::Event) -> Option<DiscoveredPeer> {
-        #[allow(clippy::match_same_arms)]
+        #[expect(clippy::match_same_arms)]
         match update {
             discv5::Event::SocketUpdated(_) | discv5::Event::TalkRequest(_) |
             // `Discovered` not unique discovered peers
@@ -772,8 +772,8 @@ mod test {
 
     // Copied from sigp/discv5 with slight modification (U256 type)
     // <https://github.com/sigp/discv5/blob/master/src/kbucket/key.rs#L89-L101>
-    #[allow(unreachable_pub)]
-    #[allow(unused)]
+    #[expect(unreachable_pub)]
+    #[expect(unused)]
     #[allow(clippy::assign_op_pattern)]
     mod sigp {
         use alloy_primitives::U256;

crates/net/dns/src/lib.rs

@@ -90,7 +90,7 @@ impl DnsDiscoveryHandle {
 
 /// A client that discovers nodes via DNS.
 #[must_use = "Service does nothing unless polled"]
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct DnsDiscoveryService<R: Resolver = DnsResolver> {
     /// Copy of the sender half, so new [`DnsDiscoveryHandle`] can be created on demand.
     command_tx: UnboundedSender<DnsDiscoveryCommand>,

crates/net/downloaders/src/bodies/mod.rs

@@ -1,5 +1,5 @@
 /// A naive concurrent downloader.
-#[allow(clippy::module_inception)]
+#[expect(clippy::module_inception)]
 pub mod bodies;
 
 /// A body downloader that does nothing. Useful to build unwind-only pipelines.

crates/net/downloaders/src/bodies/task.rs

@@ -213,7 +213,7 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread")]
-    #[allow(clippy::reversed_empty_ranges)]
+    #[expect(clippy::reversed_empty_ranges)]
     async fn set_download_range_error_returned() {
         reth_tracing::init_test_tracing();
         let factory = create_test_provider_factory();

crates/net/eth-wire/tests/fuzz_roundtrip.rs

@@ -37,7 +37,7 @@ where
 macro_rules! fuzz_type_and_name {
     ( $x:ty, $fuzzname:ident ) => {
         /// Fuzzes the round-trip encoding of the type.
-        #[allow(non_snake_case)]
+        #[expect(non_snake_case)]
         #[test_fuzz]
         fn $fuzzname(thing: $x) {
             crate::roundtrip_fuzz::<$x>(thing)
@@ -46,7 +46,7 @@ macro_rules! fuzz_type_and_name {
 }
 
 #[cfg(test)]
-#[allow(missing_docs)]
+#[expect(missing_docs)]
 pub mod fuzz_rlp {
     use crate::roundtrip_encoding;
     use alloy_rlp::{RlpDecodableWrapper, RlpEncodableWrapper};

crates/net/network-api/src/noop.rs

@@ -26,7 +26,7 @@ impl NetworkInfo for NoopNetwork {
     }
 
     async fn network_status(&self) -> Result<NetworkStatus, NetworkError> {
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         Ok(NetworkStatus {
             client_version: "reth-test".to_string(),
             protocol_version: ProtocolVersion::V5 as u64,

crates/net/network/src/builder.rs

@@ -15,7 +15,7 @@ use tokio::sync::mpsc;
 pub(crate) const ETH_REQUEST_CHANNEL_CAPACITY: usize = 256;
 
 /// A builder that can configure all components of the network.
-#[allow(missing_debug_implementations)]
+#[expect(missing_debug_implementations)]
 pub struct NetworkBuilder<Tx, Eth, N: NetworkPrimitives = EthNetworkPrimitives> {
     pub(crate) network: NetworkManager<N>,
     pub(crate) transactions: Tx,

crates/net/network/src/config.rs

@@ -227,7 +227,7 @@ impl NetworkConfigBuilder<EthNetworkPrimitives> {
 
 // === impl NetworkConfigBuilder ===
 
-#[allow(missing_docs)]
+#[expect(missing_docs)]
 impl<N: NetworkPrimitives> NetworkConfigBuilder<N> {
     /// Create a new builder instance with a random secret key.
     pub fn with_rng_secret_key() -> Self {

crates/net/network/src/eth_requests.rs

@@ -57,7 +57,7 @@ pub struct EthRequestHandler<C, N: NetworkPrimitives = EthNetworkPrimitives> {
     client: C,
     /// Used for reporting peers.
     // TODO use to report spammers
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     peers: PeersHandle,
     /// Incoming request from the [`NetworkManager`](crate::NetworkManager).
     incoming_requests: ReceiverStream<IncomingEthRequest<N>>,

crates/net/network/src/manager.rs

@@ -443,7 +443,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
         let status = sessions.status();
         let hello_message = sessions.hello_message();
 
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         NetworkStatus {
             client_version: hello_message.client_version,
             protocol_version: hello_message.protocol_version as u64,