refactor

- be sure we don't truncate unnecessarily.

Author: Byron

gix-worktree-state/src/checkout/chunk.rs

@@ -224,12 +224,12 @@ where
                     inner: std::io::BufWriter::with_capacity(512 * 1024, file),
                     progress: bytes,
                 };
-                let num_bytes = std::io::copy(&mut read, &mut write)?;
-                bytes_written += num_bytes;
+                let actual_bytes = std::io::copy(&mut read, &mut write)?;
+                bytes_written += actual_bytes;
                 entry::finalize_entry(
                     delayed.entry,
-                    num_bytes as usize,
                     write.inner.into_inner().map_err(std::io::IntoInnerError::into_error)?,
+                    actual_bytes,
                     set_executable_after_creation,
                 )?;
                 delayed_files += 1;

gix-worktree-state/src/checkout/entry.rs

@@ -135,7 +135,7 @@ where
             };
 
             // For possibly existing, overwritten files, we must change the file mode explicitly.
-            finalize_entry(entry, num_bytes, file, set_executable_after_creation)?;
+            finalize_entry(entry, file, num_bytes as u64, set_executable_after_creation)?;
             num_bytes
         }
         gix_index::entry::Mode::SYMLINK => {
@@ -276,23 +276,31 @@ pub(crate) fn open_file(
 }
 
 /// Close `file` and store its stats in `entry`, possibly setting `file` executable.
+///
+/// `desired_bytes` is the amount of bytes Git thinks the file should have after writing.
 pub(crate) fn finalize_entry(
     entry: &mut gix_index::Entry,
-    num_bytes: usize,
     file: std::fs::File,
+    desired_bytes: u64,
     #[cfg_attr(windows, allow(unused_variables))] set_executable_after_creation: bool,
 ) -> Result<(), crate::checkout::Error> {
     // For possibly existing, overwritten files, we must change the file mode explicitly.
     #[cfg(unix)]
     if set_executable_after_creation {
         set_executable(&file)?;
     }
-    if let Ok(num_bytes) = num_bytes.try_into() {
-        file.set_len(num_bytes)?;
+
+    let md = &gix_index::fs::Metadata::from_file(&file)?;
+    // A last sanity check: if the file wasn't truncated upon opening, which is good in case something
+    // goes wrong during writing, not everything is lost, then after writing the file is smaller than it was
+    // before, it needs truncation. We do that here.
+    let needs_truncation = md.len() > desired_bytes;
+    if needs_truncation {
+        file.set_len(desired_bytes)?;
     }
     // NOTE: we don't call `file.sync_all()` here knowing that some filesystems don't handle this well.
     //       revisit this once there is a bug to fix.
-    entry.stat = Stat::from_fs(&gix_index::fs::Metadata::from_file(&file)?)?;
+    entry.stat = Stat::from_fs(md)?;
     file.close()?;
     Ok(())
 }