From bc8a6c3cf522c527feaf8802b0444a7dc8f021d4 Mon Sep 17 00:00:00 2001
From: Romain Ruetschi <romain@informal.systems>
Date: Wed, 10 Apr 2024 21:11:22 +0200
Subject: [PATCH] Fix warnings on nightly (#1409)

---
 light-client-verifier/src/verifier.rs |  1 +
 tendermint/src/abci/event.rs          | 86 +++++++++++++--------------
 tendermint/src/merkle.rs              |  2 +-
 3 files changed, 45 insertions(+), 44 deletions(-)

diff --git a/light-client-verifier/src/verifier.rs b/light-client-verifier/src/verifier.rs
index fd2e8826c..ba8e65146 100644
--- a/light-client-verifier/src/verifier.rs
+++ b/light-client-verifier/src/verifier.rs
@@ -330,6 +330,7 @@ mod tests {
         Verdict, Verifier,
     };
 
+    #[allow(dead_code)]
     #[cfg(feature = "rust-crypto")]
     #[derive(Clone, Debug, PartialEq, Eq)]
     struct ProdVerifierSupportsCommonDerivedTraits {
diff --git a/tendermint/src/abci/event.rs b/tendermint/src/abci/event.rs
index 7a3cd3301..2ea77b1bc 100644
--- a/tendermint/src/abci/event.rs
+++ b/tendermint/src/abci/event.rs
@@ -397,59 +397,59 @@ mod tests {
         assert_eq!(event_a.eq_ignoring_index(&event_c), false);
     }
 
-    #[test]
-    fn exercise_typed_event() {
-        #[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
-        struct Payload {
-            x: u32,
-            y: u32,
-        }
+    #[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
+    struct Payload {
+        x: u32,
+        y: u32,
+    }
 
-        #[derive(Clone, Debug, PartialEq, Eq)]
-        struct MyEvent {
-            a: Payload,
-            b: Payload,
-        }
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    struct MyEvent {
+        a: Payload,
+        b: Payload,
+    }
 
-        impl From<MyEvent> for Event {
-            fn from(event: MyEvent) -> Self {
-                Event::new(
-                    "my_event",
-                    vec![
-                        ("a", serde_json::to_string(&event.a).unwrap()).index(),
-                        ("b", serde_json::to_string(&event.b).unwrap()).index(),
-                    ],
-                )
-            }
+    impl From<MyEvent> for Event {
+        fn from(event: MyEvent) -> Self {
+            Event::new(
+                "my_event",
+                vec![
+                    ("a", serde_json::to_string(&event.a).unwrap()).index(),
+                    ("b", serde_json::to_string(&event.b).unwrap()).index(),
+                ],
+            )
         }
+    }
 
-        impl TryFrom<Event> for MyEvent {
-            type Error = (); // Avoid depending on a specific error library in test code
+    impl TryFrom<Event> for MyEvent {
+        type Error = (); // Avoid depending on a specific error library in test code
 
-            fn try_from(event: Event) -> Result<Self, Self::Error> {
-                if event.kind != "my_event" {
-                    return Err(());
-                }
+        fn try_from(event: Event) -> Result<Self, Self::Error> {
+            if event.kind != "my_event" {
+                return Err(());
+            }
 
-                let a = event
-                    .attributes
-                    .iter()
-                    .find(|attr| attr.key == "a")
-                    .ok_or(())
-                    .and_then(|attr| serde_json::from_str(&attr.value).map_err(|_| ()))?;
-                let b = event
-                    .attributes
-                    .iter()
-                    .find(|attr| attr.key == "b")
-                    .ok_or(())
-                    .and_then(|attr| serde_json::from_str(&attr.value).map_err(|_| ()))?;
+            let a = event
+                .attributes
+                .iter()
+                .find(|attr| attr.key == "a")
+                .ok_or(())
+                .and_then(|attr| serde_json::from_str(&attr.value).map_err(|_| ()))?;
+            let b = event
+                .attributes
+                .iter()
+                .find(|attr| attr.key == "b")
+                .ok_or(())
+                .and_then(|attr| serde_json::from_str(&attr.value).map_err(|_| ()))?;
 
-                Ok(MyEvent { a, b })
-            }
+            Ok(MyEvent { a, b })
         }
+    }
 
-        impl TypedEvent for MyEvent {}
+    impl TypedEvent for MyEvent {}
 
+    #[test]
+    fn exercise_typed_event() {
         let t = MyEvent {
             a: Payload { x: 1, y: 2 },
             b: Payload { x: 3, y: 4 },
diff --git a/tendermint/src/merkle.rs b/tendermint/src/merkle.rs
index 63c6361fb..a3a77def8 100644
--- a/tendermint/src/merkle.rs
+++ b/tendermint/src/merkle.rs
@@ -152,7 +152,7 @@ mod tests {
         let empty_tree_root_hex =
             "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
         let empty_tree_root = &hex::decode(empty_tree_root_hex).unwrap();
-        let empty_tree: Vec<Vec<u8>> = vec![vec![]; 0];
+        let empty_tree: Vec<Vec<u8>> = vec![];
 
         let root = simple_hash_from_byte_vectors::<Sha256>(&empty_tree);
         assert_eq!(empty_tree_root, &root);