refactor: nits from nightly clippy (#962)

rnbguy · web-flow · commit 95fc7d753f28 · 2023-11-14T09:22:24.000-05:00
* use enum tuple variants directly

* use first() over get(0)

* use infallible conversion

* rm redundant export

* cargo fmt
diff --git a/crates/ibc-testkit/src/testapp/ibc/core/core_ctx.rs b/crates/ibc-testkit/src/testapp/ibc/core/core_ctx.rs
@@ -144,26 +144,28 @@ impl ValidationContext for MockContext {
         let self_chain_id = &self.host_chain_id;
         let self_revision_number = self_chain_id.revision_number();
         if self_revision_number != mock_client_state.latest_height().revision_number() {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "client is not in the same revision as the chain. expected: {}, got: {}",
-                    self_revision_number,
-                    mock_client_state.latest_height().revision_number()
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "client is not in the same revision as the chain. expected: {}, got: {}",
+                        self_revision_number,
+                        mock_client_state.latest_height().revision_number()
+                    ),
+                },
+            ));
         }
 
         let host_current_height = self.latest_height().increment();
         if mock_client_state.latest_height() >= host_current_height {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "client has latest height {} greater than or equal to chain height {}",
-                    mock_client_state.latest_height(),
-                    host_current_height
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "client has latest height {} greater than or equal to chain height {}",
+                        mock_client_state.latest_height(),
+                        host_current_height
+                    ),
+                },
+            ));
         }
 
         Ok(())
diff --git a/crates/ibc-testkit/src/testapp/ibc/core/router/mod.rs b/crates/ibc-testkit/src/testapp/ibc/core/router/mod.rs
@@ -1,5 +1,4 @@
 mod context;
 mod types;
 
-pub use context::*;
 pub use types::*;
diff --git a/crates/ibc-testkit/src/utils/dummies/core/client/msg_create_client.rs b/crates/ibc-testkit/src/utils/dummies/core/client/msg_create_client.rs
@@ -15,7 +15,7 @@ pub fn dummy_raw_msg_create_client() -> MsgCreateClient {
 
     MsgCreateClient {
         client_state: Some(Any::from(tm_client_state)),
-        consensus_state: Some(Any::from(TmConsensusState::try_from(tm_header).unwrap())),
+        consensus_state: Some(Any::from(TmConsensusState::from(tm_header))),
         signer: dummy_bech32_account(),
     }
 }
diff --git a/crates/ibc/src/applications/transfer/msgs/transfer.rs b/crates/ibc/src/applications/transfer/msgs/transfer.rs
@@ -70,7 +70,7 @@ impl TryFrom<RawMsgTransfer> for MsgTransfer {
 
         // Packet timeout height and packet timeout timestamp cannot both be unset.
         if !timeout_height_on_b.is_set() && !timeout_timestamp_on_b.is_set() {
-            return Err(PacketError::MissingTimeout).map_err(ContextError::from)?;
+            return Err(ContextError::from(PacketError::MissingTimeout))?;
         }
 
         Ok(MsgTransfer {
diff --git a/crates/ibc/src/core/ics02_client/handler/update_client.rs b/crates/ibc/src/core/ics02_client/handler/update_client.rs
@@ -99,7 +99,7 @@ where
 
         {
             let event = {
-                let consensus_height = consensus_heights.get(0).ok_or(ClientError::Other {
+                let consensus_height = consensus_heights.first().ok_or(ClientError::Other {
                     description: "client update state returned no updated height".to_string(),
                 })?;
 
diff --git a/crates/ibc/src/core/ics03_connection/delay.rs b/crates/ibc/src/core/ics03_connection/delay.rs
@@ -33,21 +33,23 @@ where
     let earliest_valid_time = (last_client_update_time + conn_delay_time_period)
         .map_err(ConnectionError::TimestampOverflow)?;
     if current_host_time < earliest_valid_time {
-        return Err(ConnectionError::NotEnoughTimeElapsed {
-            current_host_time,
-            earliest_valid_time,
-        })
-        .map_err(ContextError::ConnectionError);
+        return Err(ContextError::ConnectionError(
+            ConnectionError::NotEnoughTimeElapsed {
+                current_host_time,
+                earliest_valid_time,
+            },
+        ));
     }
 
     // Verify that the current host chain height is later than the last client update height
     let earliest_valid_height = last_client_update_height.add(conn_delay_height_period);
     if current_host_height < earliest_valid_height {
-        return Err(ConnectionError::NotEnoughBlocksElapsed {
-            current_host_height,
-            earliest_valid_height,
-        })
-        .map_err(ContextError::ConnectionError);
+        return Err(ContextError::ConnectionError(
+            ConnectionError::NotEnoughBlocksElapsed {
+                current_host_height,
+                earliest_valid_height,
+            },
+        ));
     };
 
     Ok(())
diff --git a/crates/ibc/src/core/ics23_commitment/merkle.rs b/crates/ibc/src/core/ics23_commitment/merkle.rs
@@ -145,10 +145,10 @@ impl MerkleProof {
         // verify the absence of key in lowest subtree
         let proof = self
             .proofs
-            .get(0)
+            .first()
             .ok_or(CommitmentError::InvalidMerkleProof)?;
         let spec = ics23_specs
-            .get(0)
+            .first()
             .ok_or(CommitmentError::InvalidMerkleProof)?;
         // keys are represented from root-to-leaf
         let key = keys
diff --git a/crates/ibc/src/hosts/tendermint/validate_self_client.rs b/crates/ibc/src/hosts/tendermint/validate_self_client.rs
@@ -38,47 +38,51 @@ pub trait ValidateSelfClientContext {
 
         let self_chain_id = self.chain_id();
         if self_chain_id != &tm_client_state.chain_id {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "invalid chain-id. expected: {}, got: {}",
-                    self_chain_id, tm_client_state.chain_id
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "invalid chain-id. expected: {}, got: {}",
+                        self_chain_id, tm_client_state.chain_id
+                    ),
+                },
+            ));
         }
 
         let self_revision_number = self_chain_id.revision_number();
         if self_revision_number != tm_client_state.latest_height().revision_number() {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "client is not in the same revision as the chain. expected: {}, got: {}",
-                    self_revision_number,
-                    tm_client_state.latest_height().revision_number()
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "client is not in the same revision as the chain. expected: {}, got: {}",
+                        self_revision_number,
+                        tm_client_state.latest_height().revision_number()
+                    ),
+                },
+            ));
         }
 
         if tm_client_state.latest_height() >= self.host_current_height() {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "client has latest height {} greater than or equal to chain height {}",
-                    tm_client_state.latest_height(),
-                    self.host_current_height()
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "client has latest height {} greater than or equal to chain height {}",
+                        tm_client_state.latest_height(),
+                        self.host_current_height()
+                    ),
+                },
+            ));
         }
 
         if self.proof_specs() != &tm_client_state.proof_specs {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "client has invalid proof specs. expected: {:?}, got: {:?}",
-                    self.proof_specs(),
-                    tm_client_state.proof_specs
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "client has invalid proof specs. expected: {:?}, got: {:?}",
+                        self.proof_specs(),
+                        tm_client_state.proof_specs
+                    ),
+                },
+            ));
         }
 
         let _ = {
@@ -94,36 +98,37 @@ pub trait ValidateSelfClientContext {
         };
 
         if self.unbonding_period() != tm_client_state.unbonding_period {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "invalid unbonding period. expected: {:?}, got: {:?}",
-                    self.unbonding_period(),
-                    tm_client_state.unbonding_period,
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "invalid unbonding period. expected: {:?}, got: {:?}",
+                        self.unbonding_period(),
+                        tm_client_state.unbonding_period,
+                    ),
+                },
+            ));
         }
 
         if tm_client_state.unbonding_period < tm_client_state.trusting_period {
-            return Err(ConnectionError::InvalidClientState{ reason: format!(
+            return Err(ContextError::ConnectionError(ConnectionError::InvalidClientState{ reason: format!(
                 "unbonding period must be greater than trusting period. unbonding period ({:?}) < trusting period ({:?})",
                 tm_client_state.unbonding_period,
                 tm_client_state.trusting_period
-            )})
-            .map_err(ContextError::ConnectionError);
+            )}));
         }
 
         if !tm_client_state.upgrade_path.is_empty()
             && self.upgrade_path() != tm_client_state.upgrade_path
         {
-            return Err(ConnectionError::InvalidClientState {
-                reason: format!(
-                    "invalid upgrade path. expected: {:?}, got: {:?}",
-                    self.upgrade_path(),
-                    tm_client_state.upgrade_path
-                ),
-            })
-            .map_err(ContextError::ConnectionError);
+            return Err(ContextError::ConnectionError(
+                ConnectionError::InvalidClientState {
+                    reason: format!(
+                        "invalid upgrade path. expected: {:?}, got: {:?}",
+                        self.upgrade_path(),
+                        tm_client_state.upgrade_path
+                    ),
+                },
+            ));
         }
 
         Ok(())

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ pub fn dummy_raw_msg_create_client() -> MsgCreateClient {`
`15`	`15`
`16`	`16`	`MsgCreateClient {`
`17`	`17`	`client_state: Some(Any::from(tm_client_state)),`
`18`		`- consensus_state: Some(Any::from(TmConsensusState::try_from(tm_header).unwrap())),`
	`18`	`+ consensus_state: Some(Any::from(TmConsensusState::from(tm_header))),`
`19`	`19`	`signer: dummy_bech32_account(),`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ impl TryFrom<RawMsgTransfer> for MsgTransfer {`
`70`	`70`
`71`	`71`	`// Packet timeout height and packet timeout timestamp cannot both be unset.`
`72`	`72`	`if !timeout_height_on_b.is_set() && !timeout_timestamp_on_b.is_set() {`
`73`		`- return Err(PacketError::MissingTimeout).map_err(ContextError::from)?;`
	`73`	`+ return Err(ContextError::from(PacketError::MissingTimeout))?;`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`Ok(MsgTransfer {`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ where`
`99`	`99`
`100`	`100`	`{`
`101`	`101`	`let event = {`
`102`		`- let consensus_height = consensus_heights.get(0).ok_or(ClientError::Other {`
	`102`	`+ let consensus_height = consensus_heights.first().ok_or(ClientError::Other {`
`103`	`103`	`description: "client update state returned no updated height".to_string(),`
`104`	`104`	`})?;`
`105`	`105`