Fix more 1.92 Clippies

CHANGELOG.md

@@ -36,6 +36,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Docker compose files**: replace old environment by local in
   docker-compose.block-producer.yml
   ([#1916](https://github.com/o1-labs/mina-rust/pull/1916)
+- **CI**: Remove clippy exceptions for large enum/err variants added
+  as part of the Rust 1.92 upgrade
+  [#1968](https://github.com/o1-labs/mina-rust/pull/1968)
 
 ### Changes
 

Makefile

@@ -262,16 +262,12 @@ format-md: ## Format all markdown and MDX files to wrap at 80 characters
 .PHONY: lint
 lint: ## Run linter (clippy)
 	cargo clippy --all-targets -- -D warnings \
-	  --allow clippy::large_enum_variant \
-	  --allow clippy::result-large-err \
-	  --allow unused
+	  --allow unused_assignments
 
 .PHONY: lint-beta
 lint-beta: ## Run linter (clippy) using beta Rust
 	cargo +beta clippy --all-targets -- -D warnings \
-	  --allow clippy::large_enum_variant \
-	  --allow clippy::result-large-err \
-	  --allow unused
+	  --allow unused_assignments
 
 .PHONY: lint-bash
 lint-bash: ## Check all shell scripts using shellcheck

crates/cli/src/commands/misc.rs

@@ -1,5 +1,4 @@
 use libp2p_identity::PeerId;
-use mina_node_account::AccountPublicKey;
 use node::{account::AccountSecretKey, p2p::identity::SecretKey};
 use std::{fs::File, io::Write};
 

crates/ledger/src/proofs/transaction.rs

@@ -4397,6 +4397,7 @@ pub(super) mod tests {
 
     /// External worker input.
     #[derive(Debug, BinProtRead, BinProtWrite)]
+    #[expect(clippy::large_enum_variant, reason = "This enum is only used in tests")]
     pub enum ExternalSnarkWorkerRequest {
         /// Queries worker for readiness, expected reply is `true`.
         AwaitReadiness,

crates/ledger/src/scan_state/scan_state.rs

@@ -2142,7 +2142,10 @@ impl ScanState {
                     }
                 };
 
-                Ok(snark_work::spec::Work::Transition((statement, witness)))
+                Ok(snark_work::spec::Work::Transition((
+                    statement,
+                    Box::new(witness),
+                )))
             }
             Extracted::Second(s) => {
                 let merged = s.0.statement().merge(&s.1.statement())?;
@@ -2196,7 +2199,10 @@ impl ScanState {
                     }
                 };
 
-                Some(snark_work::spec::Work::Transition((statement, witness)))
+                Some(snark_work::spec::Work::Transition((
+                    statement,
+                    Box::new(witness),
+                )))
             }
             Extracted::Second(s) => {
                 let merged = s.0.statement().merge(&s.1.statement()).unwrap();

crates/ledger/src/scan_state/snark_work.rs

@@ -5,7 +5,7 @@ pub mod spec {
     };
 
     pub enum Work {
-        Transition((Box<Statement<()>>, TransactionWitness)),
+        Transition((Box<Statement<()>>, Box<TransactionWitness>)),
         Merge(Box<(Statement<()>, Box<(LedgerProof, LedgerProof)>)>),
     }
 }
@@ -30,6 +30,7 @@ mod tests {
 
     /// External worker input.
     #[derive(Debug, BinProtRead, BinProtWrite)]
+    #[expect(clippy::large_enum_variant, reason = "This enum is only used in tests")]
     pub enum ExternalSnarkWorkerRequest {
         /// Queries worker for readiness, expected reply is `true`.
         AwaitReadiness,

crates/node/src/event_source/event_source_actions.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 pub type EventSourceActionWithMeta = redux::ActionWithMeta<EventSourceAction>;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[expect(clippy::large_enum_variant, reason = "This enum extends super::Event")]
 pub enum EventSourceAction {
     /// Notify state machine that the new events might be received/available,
     /// so trigger processing of those events.

crates/node/src/event_source/event_source_effects.rs

@@ -261,10 +261,7 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                             store.dispatch(P2pDisconnectionAction::Init { peer_id, reason });
                         }
                         Ok(message) => {
-                            store.dispatch(P2pChannelsMessageReceivedAction {
-                                peer_id,
-                                message: Box::new(message),
-                            });
+                            store.dispatch(P2pChannelsMessageReceivedAction { peer_id, message });
                         }
                     },
                     P2pChannelEvent::Closed(peer_id, chan_id) => {
@@ -489,7 +486,9 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
             Event::GenesisLoad(res) => match res {
                 Err(err) => todo!("error while trying to load genesis config/ledger. - {err}"),
                 Ok(data) => {
-                    store.dispatch(TransitionFrontierGenesisAction::LedgerLoadSuccess { data });
+                    store.dispatch(TransitionFrontierGenesisAction::LedgerLoadSuccess {
+                        data: Box::new(data),
+                    });
                 }
             },
         },

crates/node/src/ledger/ledger_manager.rs

@@ -22,38 +22,48 @@ use std::collections::BTreeMap;
 /// can't be expressed in the Rust type system at the moment. For this
 /// reason this type is private while functions wrapping the whole call
 /// to the service are exposed as the service's methods.
-#[allow(dead_code)] // TODO
+#[expect(
+    clippy::large_enum_variant,
+    reason = "This is storing large messages, but size difference is only 2x between largest and second-largest variants"
+)]
 pub(super) enum LedgerRequest {
     Write(LedgerWriteRequest),
     Read(LedgerReadId, LedgerReadRequest),
+    /// expected response: `LedgerHash`
     AccountsSet {
         snarked_ledger_hash: LedgerHash,
         parent: LedgerAddress,
         accounts: Vec<MinaBaseAccountBinableArgStableV2>,
-    }, // expected response: LedgerHash
+    },
+    /// expected response: `Vec<Account>`
     AccountsGet {
         ledger_hash: LedgerHash,
         account_ids: Vec<AccountId>,
-    }, // expected response: Vec<Account>
+    },
+    /// expected response: `ChildHashes`
     ChildHashesGet {
         snarked_ledger_hash: LedgerHash,
         parent: LedgerAddress,
-    }, // expected response: ChildHashes
+    },
+    /// expected response: `Success`
     ComputeSnarkedLedgerHashes {
         snarked_ledger_hash: LedgerHash,
-    }, // expected response: Success
+    },
+    /// expected response: `SnarkedLedgerContentsCopied`
     CopySnarkedLedgerContentsForSync {
         origin_snarked_ledger_hash: Vec<LedgerHash>,
         target_snarked_ledger_hash: LedgerHash,
         overwrite: bool,
-    }, // expected response: SnarkedLedgerContentsCopied
+    },
+    /// expected response: `ProducersWithDelegatesMap`
     GetProducersWithDelegates {
         ledger_hash: LedgerHash,
         filter: fn(&CompressedPubKey) -> bool,
-    }, // expected response: ProducersWithDelegatesMap
+    },
+    /// expected response: `LedgerMask`
     GetMask {
         ledger_hash: LedgerHash,
-    }, // expected response: LedgerMask
+    },
     InsertGenesisLedger {
         mask: Mask,
     },

crates/node/src/ledger/ledger_service.rs

@@ -1271,7 +1271,7 @@ impl LedgerCtx {
             .view()
             .map(|jobs| {
                 let jobs = jobs.collect::<Vec<JobValueWithIndex<'_>>>();
-                let mut iter = jobs.iter().peekable();
+                let iter = jobs.iter().peekable();
                 let mut res = Vec::with_capacity(jobs.len());
 
                 for job in iter {

crates/node/src/recorder/mod.rs

@@ -57,6 +57,10 @@ impl RecordedActionWithMeta<'_> {
         postcard::from_bytes(encoded)
     }
 
+    #[expect(
+        clippy::result_large_err,
+        reason = "The error variant is the same Self which is moved in; shouldn't blow up the stack"
+    )]
     pub fn as_action_with_meta(self) -> Result<ActionWithMeta, Self> {
         if let Some(action) = self.action {
             let action = action.into_owned();

crates/node/src/rpc/mod.rs

@@ -326,7 +326,7 @@ pub enum RpcSnarkerJobCommitResponse {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(tag = "kind")]
 pub enum RpcSnarkerJobSpecResponse {
-    Ok(SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponse),
+    Ok(Box<SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponse>),
     Err(SnarkWorkSpecError),
     JobNotFound,
 }

crates/node/src/rpc_effectful/rpc_effectful_effects.rs

@@ -541,14 +541,14 @@ pub fn rpc_effects<S: Service>(store: &mut Store<S>, action: ActionWithMeta<RpcE
             let fee = config.fee.clone();
             let input = match input {
                     Ok(instances) => RpcSnarkerJobSpecResponse::Ok(
-                        mina_p2p_messages::v2::SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponse(Some((
+                        Box::new(mina_p2p_messages::v2::SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponse(Some((
                             mina_p2p_messages::v2::SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponseA0 {
                                 instances,
                                 fee,
                             },
                             public_key,
                         )))
-                    ),
+                    )),
                     Err(err) => RpcSnarkerJobSpecResponse::Err(err),
                 };
 

crates/node/src/state.rs

@@ -459,6 +459,10 @@ impl State {
 
 #[serde_with::serde_as]
 #[derive(Debug, Clone, Serialize, Deserialize, MallocSizeOf)]
+#[expect(
+    clippy::large_enum_variant,
+    reason = "Doesn't make sense moving redux state onto heap"
+)]
 pub enum P2p {
     Pending(#[ignore_malloc_size_of = "constant"] P2pConfig),
     Ready(P2pState),

crates/node/src/transition_frontier/genesis/transition_frontier_genesis_actions.rs

@@ -17,7 +17,7 @@ pub enum TransitionFrontierGenesisAction {
     LedgerLoadInit,
     LedgerLoadPending,
     LedgerLoadSuccess {
-        data: GenesisConfigLoaded,
+        data: Box<GenesisConfigLoaded>,
     },
     Produce,
     ProveInit,

crates/node/src/transition_frontier/genesis/transition_frontier_genesis_reducer.rs

@@ -45,7 +45,7 @@ impl TransitionFrontierGenesisState {
             TransitionFrontierGenesisAction::LedgerLoadSuccess { data } => {
                 *state = Self::LedgerLoadSuccess {
                     time: meta.time(),
-                    data: data.clone(),
+                    data: *data.clone(),
                 };
 
                 // Dispatch

crates/p2p/src/channels/streaming_rpc/p2p_channels_streaming_rpc_state.rs

@@ -9,6 +9,10 @@ use super::{
 };
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[expect(
+    clippy::large_enum_variant,
+    reason = "Happy-path variant is the redux state"
+)]
 pub enum P2pChannelsStreamingRpcState {
     Disabled,
     Enabled,

crates/p2p/src/p2p_event.rs

@@ -74,7 +74,7 @@ pub enum P2pConnectionEvent {
 pub enum P2pChannelEvent {
     Opened(PeerId, ChannelId, Result<(), String>),
     Sent(PeerId, ChannelId, MsgId, Result<(), String>),
-    Received(PeerId, Result<ChannelMsg, String>),
+    Received(PeerId, Result<Box<ChannelMsg>, String>),
     Closed(PeerId, ChannelId),
 }
 
@@ -155,7 +155,7 @@ impl fmt::Display for P2pChannelEvent {
                     Err(_) => return write!(f, "Err"),
                     Ok(msg) => {
                         write!(f, "{:?}, ", msg.channel_id())?;
-                        msg
+                        msg.as_ref()
                     }
                 };
 

crates/p2p/src/p2p_state.rs

@@ -415,7 +415,7 @@ pub enum P2pPeerStatus {
         time: redux::Timestamp,
     },
 
-    Ready(P2pPeerStatusReady),
+    Ready(Box<P2pPeerStatusReady>),
 }
 
 impl P2pPeerStatus {

crates/p2p/src/peer/p2p_peer_reducer.rs

@@ -42,11 +42,11 @@ impl P2pPeerState {
                 let Some(peer) = p2p_state.peers.get_mut(&peer_id) else {
                     return Ok(());
                 };
-                peer.status = P2pPeerStatus::Ready(P2pPeerStatusReady::new(
+                peer.status = P2pPeerStatus::Ready(Box::new(P2pPeerStatusReady::new(
                     incoming,
                     meta.time(),
                     &p2p_state.config.enabled_channels,
-                ));
+                )));
 
                 if !peer.is_libp2p {
                     let (dispatcher, state) = state_context.into_dispatcher_and_state();