Fix clippy::cast_possible_truncation (#1423)

Author: SchahinRohani

.bazelrc

@@ -120,7 +120,7 @@ build --@rules_rust//:clippy_flag=-Wclippy::unimplemented
 build --@rules_rust//:clippy_flag=-Aclippy::unwrap_in_result
 build --@rules_rust//:clippy_flag=-Aclippy::unwrap_used
 build --@rules_rust//:clippy_flag=-Wclippy::use_debug
-build --@rules_rust//:clippy_flag=-Aclippy::cast_possible_truncation
+build --@rules_rust//:clippy_flag=-Dclippy::cast_possible_truncation
 build --@rules_rust//:clippy_flag=-Aclippy::cast_possible_wrap
 build --@rules_rust//:clippy_flag=-Aclippy::cast_precision_loss
 build --@rules_rust//:clippy_flag=-Aclippy::cast_sign_loss

Cargo.toml

@@ -180,7 +180,7 @@ too-long-first-doc-paragraph = { level = "allow" }              # TODO(jhpratt)
 uninhabited-references = { level = "allow", priority = 1 }      # rust-lang/rust-clippy#11984
 
 # TODO(palfrey): Remove these to get to pedantic.
-cast_possible_truncation = { level = "allow", priority = 1 }
+cast_possible_truncation = { level = "deny", priority = 1 }
 cast_possible_wrap = { level = "allow", priority = 1 }
 cast_precision_loss = { level = "allow", priority = 1 }
 cast_sign_loss = { level = "allow", priority = 1 }

nativelink-scheduler/src/awaited_action_db/awaited_action.rs

@@ -239,29 +239,36 @@ impl MetricsComponent for AwaitedActionSortKey {
 }
 
 impl AwaitedActionSortKey {
-    #[rustfmt::skip]
     const fn new(priority: i32, insert_timestamp: u32) -> Self {
-        // Shift `new_priority` so [`i32::MIN`] is represented by zero.
-        // This makes it so any negative values are positive, but
-        // maintains ordering.
-        const MIN_I32: i64 = (i32::MIN as i64).abs();
-        let priority = ((priority as i64 + MIN_I32) as u32).to_be_bytes();
+        // Shift the signed i32 range [i32::MIN, i32::MAX] to the unsigned u32 range
+        // [0, u32::MAX] to preserve ordering when we convert to bytes for sorting.
+        let priority_u32 = i32::MIN.unsigned_abs().wrapping_add_signed(priority);
+        let priority = priority_u32.to_be_bytes();
 
         // Invert our timestamp so the larger the timestamp the lower the number.
         // This makes timestamp descending order instead of ascending.
         let timestamp = (insert_timestamp ^ u32::MAX).to_be_bytes();
 
         Self(u64::from_be_bytes([
-            priority[0], priority[1], priority[2], priority[3],
-            timestamp[0], timestamp[1], timestamp[2], timestamp[3],
+            priority[0],
+            priority[1],
+            priority[2],
+            priority[3],
+            timestamp[0],
+            timestamp[1],
+            timestamp[2],
+            timestamp[3],
         ]))
     }
 
     fn new_with_unique_key(priority: i32, insert_timestamp: &SystemTime) -> Self {
-        let timestamp = insert_timestamp
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_secs() as u32;
+        let timestamp = u32::try_from(
+            insert_timestamp
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_secs(),
+        )
+        .unwrap_or(u32::MAX);
         Self::new(priority, timestamp)
     }
 

nativelink-scheduler/tests/redis_store_awaited_action_db_test.rs

@@ -247,7 +247,7 @@ impl Mocks for FakeRedisBackend {
                     }
                 }
             }
-            results[0] = ((results.len() - 1) as u32).into();
+            results[0] = u32::try_from(results.len() - 1).unwrap_or(u32::MAX).into();
             return Ok(RedisValue::Array(vec![
                 RedisValue::Array(results),
                 RedisValue::Integer(0), // Means no more items in cursor.

nativelink-service/src/bytestream_server.rs

@@ -494,9 +494,10 @@ impl ByteStreamServer {
                         }
                         continue;
                     }
-                    write_request
-                        .data
-                        .slice((tx.get_bytes_written() - write_offset) as usize..)
+                    write_request.data.slice(
+                        usize::try_from(tx.get_bytes_written() - write_offset)
+                            .unwrap_or(usize::MAX)..,
+                    )
                 } else {
                     if write_offset != tx.get_bytes_written() {
                         return Err(make_input_err!(

nativelink-service/src/cas_server.rs

@@ -278,9 +278,12 @@ impl CasServer {
                     .err_tip(|| "In Directory::file::digest")?;
                 deque.push_back(digest);
             }
+
+            let page_size_usize = usize::try_from(page_size).unwrap_or(usize::MAX);
+
             if page_token_matched {
                 directories.push(directory);
-                if directories.len() as i32 == page_size {
+                if directories.len() == page_size_usize {
                     break;
                 }
             }

nativelink-service/tests/bep_server_test.rs

@@ -331,7 +331,10 @@ async fn publish_build_tool_event_stream_test() -> Result<(), Box<dyn core::erro
             let (mut writer, mut reader) = make_buf_channel_pair();
             bep_store
                 .get_part(
-                    store_keys[sequence_number as usize - 1].clone(),
+                    store_keys[usize::try_from(sequence_number)
+                        .expect("sequence_number exceeds usize::MAX")
+                        - 1]
+                    .clone(),
                     &mut writer,
                     0,
                     None,

nativelink-store/src/compression_store.rs

@@ -195,7 +195,8 @@ impl UploadState {
                 usize::try_from(max_index_count)
                     .err_tip(|| "Could not convert max_index_count to usize")?
             ],
-            index_count: max_index_count as u32,
+            index_count: u32::try_from(max_index_count)
+                .err_tip(|| "Could not convert max_index_count to u32")?,
             uncompressed_data_size: 0, // Updated later.
             config: header.config,
             version: CURRENT_STREAM_FORMAT_VERSION,
@@ -361,14 +362,18 @@ impl StoreDriver for CompressionStore {
                 }
 
                 // Now fill the size in our slice.
-                LittleEndian::write_u32(&mut compressed_data_buf[1..5], compressed_data_sz as u32);
+                LittleEndian::write_u32(
+                    &mut compressed_data_buf[1..5],
+                    u32::try_from(compressed_data_sz).unwrap_or(u32::MAX),
+                );
 
                 // Now send our chunk.
                 tx.send(compressed_data_buf.freeze())
                     .await
                     .err_tip(|| "Failed to write chunk to inner store in compression store")?;
 
-                index.position_from_prev_index = compressed_data_sz as u32;
+                index.position_from_prev_index =
+                    u32::try_from(compressed_data_sz).unwrap_or(u32::MAX);
 
                 index_count += 1;
             }
@@ -384,7 +389,8 @@ impl StoreDriver for CompressionStore {
                 .footer
                 .indexes
                 .resize(index_count as usize, SliceIndex::default());
-            output_state.footer.index_count = output_state.footer.indexes.len() as u32;
+            output_state.footer.index_count =
+                u32::try_from(output_state.footer.indexes.len()).unwrap_or(u32::MAX);
             output_state.footer.uncompressed_data_size = received_amt;
             {
                 // Write Footer.
@@ -395,7 +401,7 @@ impl StoreDriver for CompressionStore {
 
                 let mut footer = BytesMut::with_capacity(1 + 4 + serialized_footer.len());
                 footer.put_u8(FOOTER_FRAME_TYPE);
-                footer.put_u32_le(serialized_footer.len() as u32);
+                footer.put_u32_le(u32::try_from(serialized_footer.len()).unwrap_or(u32::MAX));
                 footer.extend_from_slice(&serialized_footer);
 
                 tx.send(footer.freeze())
@@ -453,7 +459,7 @@ impl StoreDriver for CompressionStore {
                 };
                 let header_size = serialized_size(&EMPTY_HEADER, self.bincode_config)?;
                 let chunk = rx
-                    .consume(Some(header_size as usize))
+                    .consume(Some(usize::try_from(header_size).unwrap_or(usize::MAX)))
                     .await
                     .err_tip(|| "Failed to read header in get_part compression store")?;
                 error_if!(
@@ -536,9 +542,13 @@ impl StoreDriver for CompressionStore {
                     let new_uncompressed_data_sz =
                         uncompressed_data_sz + uncompressed_chunk_sz as u64;
                     if new_uncompressed_data_sz >= offset && remaining_bytes_to_send > 0 {
-                        let start_pos = offset.saturating_sub(uncompressed_data_sz) as usize;
+                        let start_pos =
+                            usize::try_from(offset.saturating_sub(uncompressed_data_sz))
+                                .unwrap_or(usize::MAX);
                         let end_pos = cmp::min(
-                            start_pos + remaining_bytes_to_send as usize,
+                            start_pos.saturating_add(
+                                usize::try_from(remaining_bytes_to_send).unwrap_or(usize::MAX),
+                            ),
                             uncompressed_chunk_sz,
                         );
                         if end_pos != start_pos {

nativelink-store/src/filesystem_store.rs

@@ -454,7 +454,7 @@ async fn add_files_to_cache<Fe: FileEntry>(
             .insert_with_time(
                 key.into_owned().into(),
                 Arc::new(file_entry),
-                time_since_anchor.as_secs() as i32,
+                i32::try_from(time_since_anchor.as_secs()).unwrap_or(i32::MAX),
             )
             .await;
         Ok(())

nativelink-store/src/gcs_client/client.rs

@@ -233,9 +233,12 @@ impl GcsClient {
         reader: &mut DropCloserReadHalf,
         max_size: u64,
     ) -> Result<(), Error> {
-        let initial_capacity = core::cmp::min(max_size as usize, 10 * 1024 * 1024);
+        let initial_capacity = core::cmp::min(
+            usize::try_from(max_size).unwrap_or(usize::MAX),
+            10 * 1024 * 1024,
+        );
         let mut data = Vec::with_capacity(initial_capacity);
-        let max_size = max_size as usize;
+        let max_size = usize::try_from(max_size).unwrap_or(usize::MAX);
         let mut total_size = 0usize;
 
         while total_size < max_size {
@@ -286,7 +289,7 @@ impl GcsClient {
 
             // Upload data in chunks
             let mut offset: u64 = 0;
-            let max_size = max_size as usize;
+            let max_size = usize::try_from(max_size).unwrap_or(usize::MAX);
             let mut total_uploaded = 0usize;
 
             while total_uploaded < max_size {
@@ -559,7 +562,11 @@ impl GcsOperations for GcsClient {
 
                     let mut rng = rand::rng();
                     let jitter_factor = rng.random::<f64>().mul_add(0.4, 0.8);
-                    retry_delay = (retry_delay as f64 * jitter_factor) as u64;
+                    retry_delay = Duration::from_millis(retry_delay)
+                        .mul_f64(jitter_factor)
+                        .as_millis()
+                        .try_into()
+                        .unwrap_or(u64::MAX);
 
                     retry_count += 1;
                 }