Merge branch 'main' into copilot/fix-f17b10ff-14e3-4e2b-9419-6198abd56d45

Author: sourcefrog

Cargo.lock

@@ -47,6 +47,7 @@ num_cpus = "1.16"
 patch = "0.7"
 path-slash = "0.2"
 quote = "1.0.35"
+reflink = "0.1"
 regex = "1.10"
 schemars = "0.9"
 serde_json = "1.0.128"

Cargo.toml

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Changed: Tree copying now attempts to use reflinks (copy-on-write) for faster copying on supported filesystems (Btrfs, XFS, APFS), with automatic fallback to regular copying.
+
 - Book: Recommend using the `-Zunstable-options --fail-fast` argument to test targets to speed up mutation testing, on recent nightly toolchains.
 
 - Fixed: Don't error if the `--in-diff` patch file contains non-UTF-8 data in non-Rust files.
@@ -10,6 +12,8 @@
 
 - New: `cargo_mutants_version` field in `outcomes.json`.
 
+- Changed: The bitwise assignment operators `&=` and `|=` are no longer mutated to `^=`. In code that accumulates bits into a bitmap starting from zero (e.g., `bitmap |= new_bits`), `|=` and `^=` produce the same result, making such mutations uninformative.
+
 ## 25.3.1 2025-08-10
 
 - Fixed: cargo-mutants' own tests were failing on nightly due to a change in the format of messages emitted by tests.

NEWS.md

@@ -83,12 +83,17 @@ like `a == 0`.
 | `&`      | `\|`,`^`           |
 | `\|`     | `&`, `^`           |
 | `^`      | `&`, `\|`          |
-| `+=` and similar assignments | assignment corresponding to the line above |
+| `&=`     | `\|=`              |
+| `\|=`    | `&=`               |
+| `^=`     | `\|=`, `&=`        |
+| `+=`, `-=`, `*=`, `/=`, `%=`, `<<=`, `>>=` | assignment corresponding to the operator above |
 
 Equality operators are not currently replaced with comparisons like `<` or `<=`
 because they are
 too prone to generate false positives, for example when unsigned integers are compared to 0.
 
+The bitwise assignment operators `&=` and `|=` are not mutated to `^=` because in code that accumulates bits (e.g., `bitmap |= new_bits`), `|=` and `^=` produce the same result when starting from zero, making such mutations uninformative.
+
 ## Unary operators
 
 Unary operators are deleted in expressions like `-a` and `!a`.

book/src/mutants.md

@@ -2,10 +2,13 @@
 
 //! Copy a source tree, with some exclusions, to a new temporary directory.
 
+use std::fs;
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+
 use anyhow::Context;
 use camino::{Utf8Path, Utf8PathBuf};
 use ignore::WalkBuilder;
-use path_slash::PathExt;
 use tempfile::TempDir;
 use tracing::{debug, warn};
 
@@ -24,6 +27,32 @@ use windows::copy_symlink;
 
 static VCS_DIRS: &[&str] = &[".git", ".hg", ".bzr", ".svn", "_darcs", ".jj", ".pijul"];
 
+/// Copy a file, attempting to use reflink if supported.
+/// Returns the number of bytes copied.
+fn copy_file(src: &Path, dest: &Path, reflink_supported: &AtomicBool) -> Result<u64> {
+    // Try reflink first if we haven't determined it's not supported
+    if reflink_supported.load(Ordering::Relaxed) {
+        match reflink::reflink(src, dest) {
+            Ok(()) => {
+                // Reflink succeeded, get file size for progress tracking
+                let metadata = fs::metadata(dest)
+                    .with_context(|| format!("Failed to get metadata for {}", dest.display()))?;
+                return Ok(metadata.len());
+            }
+            Err(e) => {
+                // On Windows, reflink can fail without returning ErrorKind::Unsupported,
+                // so we give up on reflinks after any error to avoid repeated failures.
+                reflink_supported.store(false, Ordering::Relaxed);
+                debug!("Reflink failed: {}, falling back to regular copy", e);
+            }
+        }
+    }
+
+    // Fall back to regular copy
+    fs::copy(src, dest)
+        .with_context(|| format!("Failed to copy {} to {}", src.display(), dest.display()))
+}
+
 /// Copy a source tree, with some exclusions, to a new temporary directory.
 pub fn copy_tree(
     from_path: &Utf8Path,
@@ -33,6 +62,7 @@ pub fn copy_tree(
 ) -> Result<TempDir> {
     let mut total_bytes = 0;
     let mut total_files = 0;
+    let reflink_supported = AtomicBool::new(true);
     let temp_dir = tempfile::Builder::new()
         .prefix(name_base)
         .suffix(".tmp")
@@ -86,12 +116,8 @@ pub fn copy_tree(
             )
         })?;
         if ft.is_file() {
-            let bytes_copied = std::fs::copy(entry.path(), &dest_path).with_context(|| {
-                format!(
-                    "Failed to copy {:?} to {dest_path:?}",
-                    entry.path().to_slash_lossy(),
-                )
-            })?;
+            let bytes_copied =
+                copy_file(entry.path(), dest_path.as_std_path(), &reflink_supported)?;
             total_bytes += bytes_copied;
             total_files += 1;
             console.copy_progress(dest, total_bytes);
@@ -112,7 +138,8 @@ pub fn copy_tree(
         }
     }
     console.finish_copy(dest);
-    debug!(?total_bytes, ?total_files, temp_dir = ?temp_dir.path(), "Copied source tree");
+    let reflink_used = reflink_supported.load(Ordering::Relaxed);
+    debug!(?total_bytes, ?total_files, ?reflink_used, temp_dir = ?temp_dir.path(), "Copied source tree");
     Ok(temp_dir)
 }
 

src/copy_tree.rs

@@ -591,9 +591,9 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
             BinOp::Shr(_) => vec![quote! {<<}],
             BinOp::ShrAssign(_) => vec![quote! {<<=}],
             BinOp::BitAnd(_) => vec![quote! {|}, quote! {^}],
-            BinOp::BitAndAssign(_) => vec![quote! {|=}, quote! {^=}],
+            BinOp::BitAndAssign(_) => vec![quote! {|=}],
             BinOp::BitOr(_) => vec![quote! {&}, quote! {^}],
-            BinOp::BitOrAssign(_) => vec![quote! {&=}, quote! {^=}],
+            BinOp::BitOrAssign(_) => vec![quote! {&=}],
             BinOp::BitXor(_) => vec![quote! {|}, quote! {&}],
             BinOp::BitXorAssign(_) => vec![quote! {|=}, quote! {&=}],
             _ => {
@@ -1389,14 +1389,8 @@ mod test {
             mutate_expr("a /= b"),
             &["replace /= with %=", "replace /= with *="]
         );
-        assert_eq!(
-            mutate_expr("a &= b"),
-            &["replace &= with |=", "replace &= with ^="]
-        );
-        assert_eq!(
-            mutate_expr("a |= b"),
-            &["replace |= with &=", "replace |= with ^="]
-        );
+        assert_eq!(mutate_expr("a &= b"), &["replace &= with |="]);
+        assert_eq!(mutate_expr("a |= b"), &["replace |= with &="]);
         assert_eq!(
             mutate_expr("a ^= b"),
             &["replace ^= with |=", "replace ^= with &="]