chore: Error on clippy::cast_lossless

This fires when there is a guaranteed lossless type conversion that could replace a cast.

.cargo/config

@@ -8,4 +8,5 @@ xclippy = [
     "-Wclippy::all",
     "-Wclippy::disallowed_methods",
     "-Wclippy::match_same_arms",
+    "-Wclippy::cast_lossless",
 ]

fcomm/src/lib.rs

@@ -939,7 +939,7 @@ impl<'a> Proof<'a, S1> {
 
             let chunk_frame_count = self.reduction_count.count();
             let expected_steps =
-                (iterations / chunk_frame_count) + (iterations % chunk_frame_count != 0) as usize;
+                (iterations / chunk_frame_count) + usize::from(iterations % chunk_frame_count != 0);
 
             expected_steps == num_steps
         } else {

src/circuit/circuit_frame.rs

@@ -108,7 +108,7 @@ impl<'a, F: LurkField, T: Clone + Copy + std::cmp::PartialEq, W: Copy, C: Coproc
     ) -> Vec<Self> {
         // `count` is the number of `Frames` to include per `MultiFrame`.
         let total_frames = frames.len();
-        let n = total_frames / count + (total_frames % count != 0) as usize;
+        let n = total_frames / count + usize::from(total_frames % count != 0);
         let mut multi_frames = Vec::with_capacity(n);
 
         for chunk in frames.chunks(count) {
@@ -5857,7 +5857,7 @@ mod tests {
                 .unwrap();
             let popcount_result =
                 AllocatedNum::alloc(&mut cs.namespace(|| format!("alloc popcount {x}")), || {
-                    Ok(Fr::from(x.count_ones() as u64))
+                    Ok(Fr::from(u64::from(x.count_ones())))
                 })
                 .unwrap();
 

src/coprocessor/trie/mod.rs

@@ -358,7 +358,7 @@ impl<'a, F: LurkField, const ARITY: usize, const HEIGHT: usize> Trie<'a, F, ARIT
             None => {
                 let field_significant_bits = F::NUM_BITS as usize;
                 let height_needed_for_field = field_significant_bits / arity_bits
-                    + ((field_significant_bits % arity_bits != 0) as usize);
+                    + usize::from(field_significant_bits % arity_bits != 0);
 
                 // HEIGHT must be exactly the minimum required so that every field element has a unique path.
                 assert_eq!(height_needed_for_field, HEIGHT);

src/field.rs

@@ -162,11 +162,11 @@ pub trait LurkField: PrimeField + PrimeFieldBits {
 
     /// Constructs a field element from a u32
     fn from_u32(x: u32) -> Self {
-        (x as u64).into()
+        u64::from(x).into()
     }
     /// Constructs a field element from a u16
     fn from_u16(x: u16) -> Self {
-        (x as u64).into()
+        u64::from(x).into()
     }
     /// Constructs a field element from a char
     fn from_char(x: char) -> Self {
@@ -377,7 +377,7 @@ pub mod tests {
         let mut res = F::ZERO;
         let mut bs = bs.iter().rev().peekable();
         while let Some(b) = bs.next() {
-            let b: F = (*b as u64).into();
+            let b: F = u64::from(*b).into();
             if bs.peek().is_none() {
                 res.add_assign(b)
             } else {

src/lib.rs

@@ -1,7 +1,4 @@
-#![deny(unreachable_pub)]
-#![allow(clippy::uninlined_format_args)]
-#![warn(rust_2018_idioms, unreachable_pub)]
-
+#![deny(rust_2018_idioms, unreachable_pub)]
 #[macro_use]
 extern crate alloc;
 

src/parser/syntax.rs

@@ -171,7 +171,7 @@ fn f_from_le_bytes<F: LurkField>(bs: &[u8]) -> F {
     let mut res = F::ZERO;
     let mut bs = bs.iter().rev().peekable();
     while let Some(b) = bs.next() {
-        let b: F = (*b as u64).into();
+        let b: F = u64::from(*b).into();
         if bs.peek().is_none() {
             res.add_assign(b)
         } else {

src/proof/mod.rs

@@ -91,7 +91,7 @@ pub trait Prover<'a, 'b, F: LurkField, C: Coprocessor<F>> {
         let full_multiframe_count = raw_iterations / cfc;
         let unfull_multiframe_frame_count = raw_iterations % cfc;
         let raw_multiframe_count =
-            full_multiframe_count + (unfull_multiframe_frame_count != 0) as usize;
+            full_multiframe_count + usize::from(unfull_multiframe_frame_count != 0);
         raw_multiframe_count + self.multiframe_padding_count(raw_multiframe_count)
     }