CI: add clippy and rustfmt

Author: tarcieri

.github/workflows/test.yml

@@ -69,4 +69,24 @@ jobs:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@nightly
       - run: rustup component add miri && cargo miri setup
-      - run: cargo miri test --target ${{ matrix.target }} --all-features --lib
+      - run: cargo miri test --target ${{ matrix.target }} --all-features --lib
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: 1.92.0 # Pinned to prevent breakages
+          components: clippy
+      - run: cargo clippy --workspace --all-features --lib --bins --tests -- -D warnings
+
+  rustfmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: rustfmt
+      - run: cargo fmt --all -- --check

src/lib.rs

@@ -9,6 +9,7 @@
 // - Henry de Valence <hdevalence@hdevalence.ca>
 
 #![no_std]
+#![allow(clippy::inline_fn_without_body)]
 #![deny(missing_docs)]
 #![doc(html_logo_url = "https://doc.dalek.rs/assets/dalek-logo-clear.png")]
 
@@ -88,9 +89,9 @@
 //! [rust-timing-shield]: https://www.chosenplaintext.ca/open-source/rust-timing-shield/security
 
 use core::cmp;
+use core::hint::black_box;
 use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Neg, Not};
 use core::option::Option;
-use core::hint::black_box;
 
 /// The `Choice` struct represents a choice for use in conditional assignment.
 ///
@@ -436,7 +437,7 @@ pub trait ConditionallySelectable: Copy {
     #[inline]
     fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice) {
         let t: Self = *a;
-        a.conditional_assign(&b, choice);
+        a.conditional_assign(b, choice);
         b.conditional_assign(&t, choice);
     }
 }
@@ -642,10 +643,7 @@ impl<T> CtOption<T> {
     /// exposed.
     #[inline]
     pub fn new(value: T, is_some: Choice) -> CtOption<T> {
-        CtOption {
-            value: value,
-            is_some: is_some,
-        }
+        CtOption { value, is_some }
     }
 
     /// Returns the contained value, consuming the `self` value.

tests/mod.rs

@@ -10,23 +10,23 @@ fn slices_equal_different_lengths() {
     let a: [u8; 3] = [0, 0, 0];
     let b: [u8; 4] = [0, 0, 0, 0];
 
-    assert_eq!((&a).ct_eq(&b).unwrap_u8(), 1);
+    assert_eq!(a.ct_eq(&b).unwrap_u8(), 1);
 }
 
 #[test]
 fn slices_equal() {
     let a: [u8; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
     let b: [u8; 8] = [1, 2, 3, 4, 4, 3, 2, 1];
 
-    let a_eq_a = (&a).ct_eq(&a);
-    let a_eq_b = (&a).ct_eq(&b);
+    let a_eq_a = a.ct_eq(&a);
+    let a_eq_b = a.ct_eq(&b);
 
     assert_eq!(a_eq_a.unwrap_u8(), 1);
     assert_eq!(a_eq_b.unwrap_u8(), 0);
 
     let c: [u8; 16] = [0u8; 16];
 
-    let a_eq_c = (&a).ct_eq(&c);
+    let a_eq_c = a.ct_eq(&c);
     assert_eq!(a_eq_c.unwrap_u8(), 0);
 }
 
@@ -141,18 +141,18 @@ fn conditional_select_choice() {
     let t = Choice::from(1);
     let f = Choice::from(0);
 
-    assert_eq!(bool::from(Choice::conditional_select(&t, &f, f)), true);
-    assert_eq!(bool::from(Choice::conditional_select(&t, &f, t)), false);
-    assert_eq!(bool::from(Choice::conditional_select(&f, &t, f)), false);
-    assert_eq!(bool::from(Choice::conditional_select(&f, &t, t)), true);
+    assert!(bool::from(Choice::conditional_select(&t, &f, f)));
+    assert!(!bool::from(Choice::conditional_select(&t, &f, t)));
+    assert!(!bool::from(Choice::conditional_select(&f, &t, f)));
+    assert!(bool::from(Choice::conditional_select(&f, &t, t)));
 }
 
 #[test]
 fn choice_equal() {
-    assert!(Choice::from(0).ct_eq(&Choice::from(0)).unwrap_u8() == 1);
-    assert!(Choice::from(0).ct_eq(&Choice::from(1)).unwrap_u8() == 0);
-    assert!(Choice::from(1).ct_eq(&Choice::from(0)).unwrap_u8() == 0);
-    assert!(Choice::from(1).ct_eq(&Choice::from(1)).unwrap_u8() == 1);
+    assert_eq!(Choice::from(0).ct_eq(&Choice::from(0)).unwrap_u8(), 1);
+    assert_eq!(Choice::from(0).ct_eq(&Choice::from(1)).unwrap_u8(), 0);
+    assert_eq!(Choice::from(1).ct_eq(&Choice::from(0)).unwrap_u8(), 0);
+    assert_eq!(Choice::from(1).ct_eq(&Choice::from(1)).unwrap_u8(), 1);
 }
 
 #[test]
@@ -284,65 +284,65 @@ fn test_ctoption() {
     ));
 
     // Test (in)equality
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(0))
             .ct_eq(&CtOption::new(1, Choice::from(1)))
-            .unwrap_u8()
-            == 0
+            .unwrap_u8(),
+        0
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(1))
             .ct_eq(&CtOption::new(1, Choice::from(0)))
-            .unwrap_u8()
-            == 0
+            .unwrap_u8(),
+        0
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(0))
             .ct_eq(&CtOption::new(2, Choice::from(1)))
-            .unwrap_u8()
-            == 0
+            .unwrap_u8(),
+        0
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(1))
             .ct_eq(&CtOption::new(2, Choice::from(0)))
-            .unwrap_u8()
-            == 0
+            .unwrap_u8(),
+        0
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(0))
             .ct_eq(&CtOption::new(1, Choice::from(0)))
-            .unwrap_u8()
-            == 1
+            .unwrap_u8(),
+        1
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(0))
             .ct_eq(&CtOption::new(2, Choice::from(0)))
-            .unwrap_u8()
-            == 1
+            .unwrap_u8(),
+        1
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(1))
             .ct_eq(&CtOption::new(2, Choice::from(1)))
-            .unwrap_u8()
-            == 0
+            .unwrap_u8(),
+        0
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(1))
             .ct_eq(&CtOption::new(2, Choice::from(1)))
-            .unwrap_u8()
-            == 0
+            .unwrap_u8(),
+        0
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(1))
             .ct_eq(&CtOption::new(1, Choice::from(1)))
-            .unwrap_u8()
-            == 1
+            .unwrap_u8(),
+        1
     );
-    assert!(
+    assert_eq!(
         CtOption::new(1, Choice::from(1))
             .ct_eq(&CtOption::new(1, Choice::from(1)))
-            .unwrap_u8()
-            == 1
+            .unwrap_u8(),
+        1
     );
 }