Fix warnings on nightly (#1409)

informalsystems · Apr 10, 2024 · bc8a6c3 · bc8a6c3
1 parent c45f593
commit bc8a6c3
Show file tree

Hide file tree

Showing 3 changed files with 45 additions and 44 deletions.
diff --git 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
@@ -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
@@ -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);