Fix clippy::cast_lossless

See [lint info](https://rust-lang.github.io/rust-clippy/master/index.html#/cast_lossless)

Automatically apply it with clippy:

```
 cargo clippy --fix --all-targets --workspace -- -A clippy::all -W clippy::cast_lossless
```

Author: nyurik

gitoxide-core/src/repository/odb.rs

@@ -133,7 +133,7 @@ pub fn statistics(
                 find::Header::Packed(packed) => {
                     self.packed_objects += 1;
                     self.packed_delta_objects += usize::from(packed.num_deltas > 0);
-                    self.total_delta_chain_length += packed.num_deltas as u64;
+                    self.total_delta_chain_length += u64::from(packed.num_deltas);
                     self.count(packed.kind, packed.object_size);
                 }
             }

gix-archive/src/write.rs

@@ -64,7 +64,7 @@ where
                                         out,
                                         match compression_level {
                                             None => flate2::Compression::default(),
-                                            Some(level) => flate2::Compression::new(level as u32),
+                                            Some(level) => flate2::Compression::new(u32::from(level)),
                                         },
                                     );
                                     let mut ar = tar::Builder::new(gz);
@@ -126,7 +126,7 @@ where
     NextFn: FnMut(&mut Stream) -> Result<Option<Entry<'_>>, gix_worktree_stream::entry::Error>,
 {
     let compression_level = match opts.format {
-        Format::Zip { compression_level } => compression_level.map(|lvl| lvl as i64),
+        Format::Zip { compression_level } => compression_level.map(|lvl| i64::from(lvl)),
         _other => return write_stream(stream, next_entry, out, opts),
     };
 

gix-commitgraph/src/file/init.rs

@@ -99,7 +99,7 @@ impl File {
         let base_graph_count = data[ofs];
         ofs += 1;
 
-        let chunks = gix_chunk::file::Index::from_bytes(&data, ofs, chunk_count as u32)?;
+        let chunks = gix_chunk::file::Index::from_bytes(&data, ofs, u32::from(chunk_count))?;
 
         let base_graphs_list_offset = chunks
             .validated_usize_offset_by_id(BASE_GRAPHS_LIST_CHUNK_ID, |chunk_range| {

gix-features/src/decode.rs

@@ -9,13 +9,13 @@ pub fn leb64_from_read(mut r: impl Read) -> Result<(u64, usize), std::io::Error>
     let mut i = 0;
     r.read_exact(&mut b)?;
     i += 1;
-    let mut value = b[0] as u64 & 0x7f;
+    let mut value = u64::from(b[0]) & 0x7f;
     while b[0] & 0x80 != 0 {
         r.read_exact(&mut b)?;
         i += 1;
         debug_assert!(i <= 10, "Would overflow value at 11th iteration");
         value += 1;
-        value = (value << 7) + (b[0] as u64 & 0x7f);
+        value = (value << 7) + (u64::from(b[0]) & 0x7f);
     }
     Ok((value, i))
 }
@@ -26,13 +26,13 @@ pub fn leb64(d: &[u8]) -> (u64, usize) {
     let mut i = 0;
     let mut c = d[i];
     i += 1;
-    let mut value = c as u64 & 0x7f;
+    let mut value = u64::from(c) & 0x7f;
     while c & 0x80 != 0 {
         c = d[i];
         i += 1;
         debug_assert!(i <= 10, "Would overflow value at 11th iteration");
         value += 1;
-        value = (value << 7) + (c as u64 & 0x7f);
+        value = (value << 7) + (u64::from(c) & 0x7f);
     }
     (value, i)
 }

gix-index/src/entry/flags.rs

@@ -115,7 +115,7 @@ pub(crate) mod at_rest {
 
     impl Flags {
         pub fn to_memory(self) -> super::Flags {
-            super::Flags::from_bits_retain(self.bits() as u32)
+            super::Flags::from_bits_retain(u32::from(self.bits()))
         }
     }
 
@@ -135,7 +135,7 @@ pub(crate) mod at_rest {
             )
         }
         pub fn to_flags(self) -> Option<super::Flags> {
-            super::Flags::from_bits((self.bits() as u32) << 16)
+            super::Flags::from_bits(u32::from(self.bits()) << 16)
         }
     }
 

gix-index/src/entry/mode.rs

@@ -69,7 +69,7 @@ impl Mode {
 
 impl From<gix_object::tree::EntryMode> for Mode {
     fn from(value: gix_object::tree::EntryMode) -> Self {
-        Self::from_bits_truncate(value.0 as u32)
+        Self::from_bits_truncate(u32::from(value.0))
     }
 }
 

gix-index/src/entry/stat.rs

@@ -21,7 +21,7 @@ impl Stat {
             check_stat, use_nsec, ..
         }: Options,
     ) -> bool {
-        match timestamp.unix_seconds().cmp(&(self.mtime.secs as i64)) {
+        match timestamp.unix_seconds().cmp(&i64::from(self.mtime.secs)) {
             Ordering::Less => true,
             Ordering::Equal if use_nsec && check_stat => timestamp.nanoseconds() <= self.mtime.nsecs,
             Ordering::Equal => true,

gix-object/src/tree/ref_iter.rs

@@ -99,7 +99,7 @@ fn mode_from_decimal(i: &[u8]) -> Option<(u32, &[u8])> {
         if *b < b'0' || *b > b'7' {
             return None;
         }
-        mode = (mode << 3) + (b - b'0') as u32;
+        mode = (mode << 3) + u32::from(b - b'0');
         spacer_pos += 1;
     }
     if i.len() < spacer_pos {

gix-odb/src/store_impls/dynamic/prefix.rs

@@ -91,7 +91,7 @@ where
                 *snapshot = self.store.load_all_indices()?;
                 let mut obj_count = 0;
                 for index in &snapshot.indices {
-                    obj_count += index.num_objects() as u64;
+                    obj_count += u64::from(index.num_objects());
                 }
                 *count = Some(obj_count);
                 Ok(obj_count)

gix-pack/src/data/delta.rs

@@ -6,7 +6,7 @@ pub fn decode_header_size(d: &[u8]) -> (u64, usize) {
     let mut consumed = 0;
     for cmd in d.iter() {
         consumed += 1;
-        size |= (*cmd as u64 & 0x7f) << i;
+        size |= (u64::from(*cmd) & 0x7f) << i;
         i += 7;
         if *cmd & 0x80 == 0 {
             break;
@@ -23,31 +23,31 @@ pub fn apply(base: &[u8], mut target: &mut [u8], data: &[u8]) {
             cmd if cmd & 0b1000_0000 != 0 => {
                 let (mut ofs, mut size): (u32, u32) = (0, 0);
                 if cmd & 0b0000_0001 != 0 {
-                    ofs = data[i] as u32;
+                    ofs = u32::from(data[i]);
                     i += 1;
                 }
                 if cmd & 0b0000_0010 != 0 {
-                    ofs |= (data[i] as u32) << 8;
+                    ofs |= u32::from(data[i]) << 8;
                     i += 1;
                 }
                 if cmd & 0b0000_0100 != 0 {
-                    ofs |= (data[i] as u32) << 16;
+                    ofs |= u32::from(data[i]) << 16;
                     i += 1;
                 }
                 if cmd & 0b0000_1000 != 0 {
-                    ofs |= (data[i] as u32) << 24;
+                    ofs |= u32::from(data[i]) << 24;
                     i += 1;
                 }
                 if cmd & 0b0001_0000 != 0 {
-                    size = data[i] as u32;
+                    size = u32::from(data[i]);
                     i += 1;
                 }
                 if cmd & 0b0010_0000 != 0 {
-                    size |= (data[i] as u32) << 8;
+                    size |= u32::from(data[i]) << 8;
                     i += 1;
                 }
                 if cmd & 0b0100_0000 != 0 {
-                    size |= (data[i] as u32) << 16;
+                    size |= u32::from(data[i]) << 16;
                     i += 1;
                 }
                 if size == 0 {