# Extract a Shared Helper from Duplicated Rust Code with Atlas (2026) > Atlas finds duplicated Rust logic with codebase_search, creates the shared module with write, and swaps each copy using one apply_patch per file. To extract a shared helper from duplicated Rust code, Atlas treats duplication as a semantic problem, not a textual one, because the copies usually differ in variable names and lifetimes. Atlas asks codebase_search for the behavior rather than the exact code, so near-duplicate functions across your crate's modules surface even when grep would miss them. The write tool creates the new shared module, apply_patch swaps each copy for a call in one reviewable patch per file, and cargo test proves nothing broke. ## Key takeaways - Duplication in Rust is semantic, not textual: codebase_search finds copies that differ in binding names and lifetimes, where grep fails. - The write tool shows the full diff in the permission prompt before the new src/util.rs is created. - apply_patch swaps one file per patch, so each Rust call-site change is independently reviewable and revertible. - cargo test runs after every swap, so a borrow-checker failure is attributed to the exact file that caused it. - A final grep pass catches leftover copies hiding in test modules, benches, or another crate in the cargo workspace. ## How do I find duplicated logic in a Rust crate that grep cannot see? Atlas finds duplicated Rust logic with codebase_search, which queries the semantic index for the behavior rather than the literal text. 2 copies of the same retry loop, one in src/client.rs and one in src/worker.rs, will differ in binding names and lifetimes, so grep misses them while a meaning-based query does not. Duplication in Rust rarely survives copy-paste unchanged. One copy borrows, another clones. One returns Result, another returns Option. Variable names drift. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so a plain-language description of the behavior ranks both copies even when they share almost no identical tokens. Atlas also indexes code by AST declarations using tree-sitter, not blind line windows, which means the hits come back as whole fn declarations and impl blocks rather than arbitrary line slices you then have to reconstruct. ## How do I confirm two Rust functions are really duplicates before merging them? Atlas reads each codebase_search hit with the read tool and confirms 2 Rust functions are genuinely equivalent before collapsing them. 3 differences disqualify a merge: a different error type, different borrow semantics, or a single early return. Functions that merely look alike are not duplicates, and merging them changes behavior. Confirmation is the step people skip, and in Rust the compiler will happily accept a merge that quietly changes semantics. Read both fn bodies in full. Check whether one takes &str and the other String, whether one propagates with the question mark operator and the other unwraps, whether lifetimes differ. Only when the copies are actually equivalent does the extraction make sense. Because Atlas keeps the full declarations in context rather than fragments, the comparison is done against real Rust code, not a summary of it. ## How does Atlas create the shared helper module in Rust? Atlas creates the shared Rust helper with the write tool, which shows the full diff in the permission prompt before the file exists. 1 new module, for example src/retry.rs, declared with a mod line and wired into the crate that Cargo.toml defines, is reviewed before a single byte lands on disk. Placement matters in Rust because module visibility is part of the design. The new helper needs a home in the crate's module tree, a pub or pub(crate) signature that matches how the callers will use it, and generics or trait bounds broad enough to cover every copy it replaces. Atlas writes the module with write, and because write shows the full diff in the permission prompt before the file is created, the signature is argued about before the swaps begin. Running rustfmt over the new module keeps it consistent with the rest of the crate. ## How do I swap each duplicate for a call without breaking the Rust build? Atlas replaces each duplicated Rust block with a call using apply_patch, 1 file per patch, so every swap is independently reviewable and revertible. A patch against src/client.rs and a patch against src/worker.rs land separately, and cargo test runs after each one rather than once at the end. One patch per file is what keeps a Rust extraction recoverable. If the third swap turns out to need a different trait bound, the first two are already green and committed rather than tangled into one giant diff. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, and Atlas snapshots file changes as git patches so a bad swap can be diffed and rolled back. Running cargo test after each swap catches a borrow-checker or trait-resolution failure at the file that caused it. ## How do I prove no duplicate Rust code survived the refactor? Atlas finishes a Rust extraction by running cargo test after every swap, then grepping once more for the old logic until the search returns 0 hits. A 4th copy hiding in a benches or examples directory is exactly the kind of leftover that a final grep pass catches. The last pass is cheap and worth it. Atlas runs cargo test with the bash tool, which records the process exit code in its metadata, so the green state is unambiguous rather than inferred from console text. Then grep sweeps the crate for the distinctive tokens the old copies shared, catching stragglers in test modules, benchmarks, or a second crate in the cargo workspace. Running rustfmt over the touched files and re-running cargo test leaves a clean, reviewable diff: one new helper, several call sites, no dead duplicates. ## Steps 1. Run atlas in a crate with a Cargo.toml and let Atlas read your modules, traits, and cargo workspace. 2. Ask codebase_search for the behavior, not the exact code, to surface near-duplicate Rust implementations that grep would miss because the copies differ in binding names and lifetimes. 3. Read each hit with the read tool and confirm the fn bodies are genuinely equivalent, checking error types, borrows, and early returns before collapsing them. 4. Create the shared helper with write, for example a new src/util.rs with a pub(crate) signature; write shows the full diff in the permission prompt before the file is created. 5. Replace each duplicate with a call using apply_patch, one file per patch, so each swap is independently reviewable and revertible. 6. Run cargo test with bash after every swap, not once at the end, so a borrow-checker or trait failure is attributed to the file that caused it. 7. Grep for the old logic one final time to prove no copy survived in tests, benches, or another crate of the cargo workspace. 8. Run rustfmt over the touched files and let Atlas stage the commit. ## FAQ ### how to find duplicated code in a rust crate with an AI agent Ask Atlas to run codebase_search for the behavior rather than the literal text. Rust copies usually differ in binding names, borrows, and lifetimes, so a semantic query finds what grep misses. ### how do i extract a shared helper function in rust safely Have Atlas create the module with write, which shows the full diff in the permission prompt, then swap each duplicate with apply_patch, one file per patch, running cargo test after every swap. ### why use apply_patch instead of edit for a rust refactor apply_patch applies a structural change as one reviewable patch per file, so each Rust call-site swap can be reviewed and reverted on its own instead of being tangled into one large diff. ### does atlas understand rust traits and modules Atlas indexes code by AST declarations using tree-sitter, not blind line windows, so hits come back as whole fn declarations and impl blocks. Run atlas in a crate with a Cargo.toml and it reads your modules, traits, and cargo workspace. ### can atlas fix borrow checker errors after a refactor Ask Atlas to fix borrow-checker errors or clippy warnings and review the diff before cargo build. Atlas runs cargo test through bash, which records the process exit code in its metadata, so failures are unambiguous. ### how do i make sure no duplicate rust code is left after extracting a helper Finish with a grep pass for the distinctive tokens the old copies shared. Leftovers commonly hide in test modules, benches, or a second crate in the same cargo workspace. ### does atlas format rust code with rustfmt Atlas can run rustfmt over the files it touched through the bash tool, so the extraction commit shows the new helper and the call sites rather than formatting churn. --- Canonical HTML: https://runatlas.sh/resources/stacks/extract-a-shared-helper-from-duplicated-code-in-rust Source of truth: aeo_pages row `/resources/stacks/extract-a-shared-helper-from-duplicated-code-in-rust` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.