Merge branch 'master' into szokeasaurusrex/implicit-clone

Author: szokeasaurusrex

src/api/data_types/chunking/upload/options.rs

@@ -1,3 +1,5 @@
+use std::num::NonZeroUsize;
+
 use serde::Deserialize;
 
 use super::{ChunkCompression, ChunkHashAlgorithm, ChunkUploadCapability};
@@ -17,7 +19,7 @@ pub struct ChunkServerOptions {
     pub max_wait: u64,
     #[expect(dead_code)]
     pub hash_algorithm: ChunkHashAlgorithm,
-    pub chunk_size: u64,
+    pub chunk_size: NonZeroUsize,
     pub concurrency: u8,
     #[serde(default)]
     pub compression: Vec<ChunkCompression>,

src/commands/build/upload.rs

@@ -507,10 +507,10 @@ fn upload_file(
     pb.enable_steady_tick(100);
     pb.set_style(progress_style);
 
-    let chunk_size = chunk_upload_options.chunk_size as usize;
-    let (checksum, checksums) = get_sha1_checksums(bytes, chunk_size)?;
+    let chunk_size = chunk_upload_options.chunk_size;
+    let (checksum, checksums) = get_sha1_checksums(bytes, chunk_size);
     let mut chunks = bytes
-        .chunks(chunk_size)
+        .chunks(chunk_size.into())
         .zip(checksums.iter())
         .map(|(data, checksum)| Chunk((*checksum, data)))
         .collect::<Vec<_>>();

src/commands/dart_symbol_map/upload.rs

@@ -159,7 +159,7 @@ pub(super) fn execute(args: DartSymbolMapUploadArgs) -> Result<()> {
             let options = ChunkOptions::new(chunk_upload_options, org, project)
                 .with_max_wait(DEFAULT_MAX_WAIT);
 
-            let chunked = Chunked::from(object, options.server_options().chunk_size as usize)?;
+            let chunked = Chunked::from(object, options.server_options().chunk_size);
             let (_uploaded, has_processing_errors) = upload_chunked_objects(&[chunked], options)?;
             if has_processing_errors {
                 bail!("Some symbol maps did not process correctly");

src/commands/upload_proguard.rs

@@ -214,6 +214,9 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         }
     }
 
+    // We are done constructing the mappings, redeclare as immutable.
+    let mappings = mappings;
+
     let api = Api::current();
     let config = Config::current();
 

src/utils/chunks/types.rs

@@ -2,8 +2,8 @@
 
 use std::borrow::Cow;
 use std::fmt::{Display, Formatter, Result as FmtResult};
+use std::num::NonZeroUsize;
 
-use anyhow::Result;
 use sha1_smol::Digest;
 use symbolic::common::DebugId;
 
@@ -37,7 +37,7 @@ pub struct Chunked<T> {
     chunks: Vec<Digest>,
 
     /// Size of a single chunk
-    chunk_size: usize,
+    chunk_size: NonZeroUsize,
 }
 
 impl<T> Chunked<T> {
@@ -63,14 +63,14 @@ where
 {
     /// Creates a new `ChunkedObject` from the given object, using
     /// the given chunk size.
-    pub fn from(object: T, chunk_size: usize) -> Result<Self> {
-        let (checksum, chunks) = fs::get_sha1_checksums(object.as_ref(), chunk_size)?;
-        Ok(Self {
+    pub fn from(object: T, chunk_size: NonZeroUsize) -> Self {
+        let (checksum, chunks) = fs::get_sha1_checksums(object.as_ref(), chunk_size);
+        Self {
             object,
             checksum,
             chunks,
             chunk_size,
-        })
+        }
     }
 
     /// Returns an iterator over all chunks of the object.
@@ -79,7 +79,7 @@ where
     pub fn iter_chunks(&self) -> impl Iterator<Item = Chunk<'_>> {
         self.object
             .as_ref()
-            .chunks(self.chunk_size)
+            .chunks(self.chunk_size.into())
             .zip(self.chunk_hashes().iter())
             .map(|(data, checksum)| Chunk((*checksum, data)))
     }

src/utils/dif_upload/mod.rs

@@ -1236,10 +1236,10 @@ fn upload_difs_chunked(
         processed.extend(source_bundles);
     }
 
+    let chunk_size = chunk_options.chunk_size;
+
     // Calculate checksums and chunks
-    let chunked = prepare_difs(processed, |m| {
-        Chunked::from(m, chunk_options.chunk_size as usize)
-    })?;
+    let chunked = prepare_difs(processed, |m| Ok(Chunked::from(m, chunk_size)))?;
 
     if options.no_upload {
         println!("{} skipping upload.", style(">").dim());

src/utils/file_upload.rs

@@ -638,9 +638,9 @@ fn upload_files_chunked(
     pb.set_style(progress_style);
 
     let view = ByteView::open(archive.path())?;
-    let (checksum, checksums) = get_sha1_checksums(&view, options.chunk_size as usize)?;
+    let (checksum, checksums) = get_sha1_checksums(&view, options.chunk_size);
     let mut chunks = view
-        .chunks(options.chunk_size as usize)
+        .chunks(options.chunk_size.into())
         .zip(checksums.iter())
         .map(|(data, checksum)| Chunk((*checksum, data)))
         .collect::<Vec<_>>();

src/utils/fs.rs

@@ -2,9 +2,10 @@ use std::env;
 use std::fs;
 use std::io;
 use std::io::{Read, Seek};
+use std::num::NonZeroUsize;
 use std::path::{Path, PathBuf};
 
-use anyhow::{bail, Result};
+use anyhow::Result;
 use flate2::read::GzDecoder;
 use log::error;
 use sha1_smol::{Digest, Sha1};
@@ -159,22 +160,18 @@ pub fn get_sha1_checksum<R: Read>(rdr: R) -> Result<Digest> {
 
 /// Returns the SHA1 hash for the entire input, as well as each chunk of it. The
 /// `chunk_size` must be non-zero.
-pub fn get_sha1_checksums(data: &[u8], chunk_size: usize) -> Result<(Digest, Vec<Digest>)> {
-    if chunk_size == 0 {
-        bail!("Chunk size may not be zero.");
-    }
-
+pub fn get_sha1_checksums(data: &[u8], chunk_size: NonZeroUsize) -> (Digest, Vec<Digest>) {
     let mut total_sha = Sha1::new();
     let mut chunks = Vec::new();
 
-    for chunk in data.chunks(chunk_size) {
+    for chunk in data.chunks(chunk_size.into()) {
         let mut chunk_sha = Sha1::new();
         chunk_sha.update(chunk);
         total_sha.update(chunk);
         chunks.push(chunk_sha.digest());
     }
 
-    Ok((total_sha.digest(), chunks))
+    (total_sha.digest(), chunks)
 }
 
 /// Checks if provided slice contains gzipped data.
@@ -245,9 +242,10 @@ mod tests {
 
     #[test]
     fn sha1_checksums_power_of_two() {
+        const NONZERO_16: NonZeroUsize = NonZeroUsize::new(16).unwrap();
+
         let data = b"this is some binary data for the test";
-        let (total_sha, chunks) =
-            get_sha1_checksums(data, 16).expect("Method should not fail because 16 is not zero");
+        let (total_sha, chunks) = get_sha1_checksums(data, NONZERO_16);
 
         assert_eq!(
             total_sha.to_string(),
@@ -268,10 +266,11 @@ mod tests {
 
     #[test]
     fn sha1_checksums_not_power_of_two() {
+        const NONZERO_17: NonZeroUsize = NonZeroUsize::new(17).unwrap();
+
         let data = b"this is some binary data for the test";
 
-        let (total_sha, chunks) =
-            get_sha1_checksums(data, 17).expect("Method should not fail because 17 is not zero");
+        let (total_sha, chunks) = get_sha1_checksums(data, NONZERO_17);
 
         assert_eq!(
             total_sha.to_string(),
@@ -289,10 +288,4 @@ mod tests {
             ]
         );
     }
-
-    #[test]
-    fn sha1_checksums_zero() {
-        let data = b"this is some binary data for the test";
-        get_sha1_checksums(data, 0).expect_err("Method should fail because 0 is zero");
-    }
 }

src/utils/proguard/upload.rs

@@ -26,10 +26,11 @@ pub fn chunk_upload(
     org: &str,
     project: &str,
 ) -> Result<()> {
+    let chunk_size = chunk_upload_options.chunk_size;
     let chunked_mappings = mappings
         .iter()
-        .map(|mapping| Chunked::from(mapping, chunk_upload_options.chunk_size as usize))
-        .collect::<Result<Vec<_>>>()?;
+        .map(|mapping| Chunked::from(mapping, chunk_size))
+        .collect::<Vec<_>>();
 
     let options =
         ChunkOptions::new(chunk_upload_options, org, project).with_max_wait(ASSEMBLE_POLL_TIMEOUT);