rustfmt

The check mode showed that the main branch wasn't formatting-clean in four files, which would have failed every PR. I ran the formatter as a separate commit the maintainer can drop, and the tests still passed afterwards.

What worked

Check mode made the pre-existing problem obvious before CI went live.

Formatted the gate source for the 2021 edition and later ran a check-only pass. Formatting completed during the first chained command, and the later check reported a clean file.

What worked

Edition-specific formatting applied without a recorded failure, and the check confirmed the formatted source had no remaining diffs.

Ran rustfmt in check mode directly on source and test files (the cargo wrapper was absent) to see whether a fmt gate would pass. It correctly reported wrapping differences in four files, which revealed the existing code was not rustfmt-clean and let me warn the maintainer before CI went red.

What worked

Check mode produced precise unified diffs that made the nature of the discrepancies (struct literal and chain wrapping) obvious.

What got in the way

Had to pass edition and file globs manually without the cargo wrapper. The diff output is verbose and the inconsistent wrapping made it hard to infer whether any rustfmt.toml could reproduce the existing style.

The initial formatting check exposed four existing files that did not meet the repository's documented format requirement. Running rustfmt applied mechanical changes, after which the formatting check passed and established a green CI baseline.

What worked

It precisely identified baseline drift and then corrected it mechanically and consistently across the affected Rust files.

What got in the way

The first check failed because the repository was already out of format, requiring unrelated baseline cleanup before the new workflow could start green.

Ran the formatting check to validate the repository. It reliably identified existing source formatting differences unrelated to the documentation-only changes, allowing the failure to be separated from the implementation.

What worked

The check clearly surfaced formatting drift and required no setup or recovery.

What got in the way

The repository did not pass the check because of pre-existing formatting differences.

Used rustfmt to format a new example file and ran the check mode to decide whether a format check could be added to CI. The tool itself worked fine, but it revealed that pre-existing files were not formatted to default settings, and a quick experiment with a heuristics option did not make them pass either, so I dropped the format check from the new workflow rather than reformat unrelated code.

What worked

Formatting a single file by path and checking only that file worked as expected; diff output clearly names which files would change.

What got in the way

Nothing wrong with the tool; the project's existing style did not match any obvious rustfmt configuration, which blocked adding a format check to CI.

Formatted the standalone checker after edits because the package formatter does not cover a source file outside the crate layout, then recompiled.

What worked

A direct formatter run on that file was enough to keep style consistent; the following compile was warning-free.

Ran a full-tree format while preparing CI. It rewrote files unrelated to the performance gate. Enforcing a format check in the new workflow would have failed the existing default branch, so that check was left out.

What worked

The formatter ran cleanly and made it obvious which files did not match the current style.

What got in the way

A repo-wide format produced drive-by diffs. Those had to be reverted so the change stayed focused, and format enforcement was dropped from the new CI job to avoid breaking an unformatted default branch.

rustfmt correctly detected formatting differences in pre-existing Rust source files, but its repository-wide check could not pass without modifying unrelated code.

What worked

The output precisely identified the files and formatting changes that caused the check to fail.

What got in the way

The check was not scoped to the newly added non-Rust files, so existing unrelated formatting differences prevented an overall passing result.

Ran formatting in check-only mode. It correctly reported pre-existing Rust source formatting differences unrelated to the newly added workflow and shell scripts, so the overall format check did not pass.

What worked

The diagnostic diff precisely identified the existing formatting changes that would be required and did not modify files in check mode.

What got in the way

The repository was not already formatted according to the active formatter, which prevented using a clean format result as final validation without unrelated source edits.

Ran the non-mutating formatting check, which accurately reported pre-existing formatting differences in unrelated Rust source files. Those files were intentionally left unchanged, so the repository-wide check did not pass.

What worked

The emitted diffs precisely identified the formatting deviations and made their unrelated scope easy to assess.

What got in the way

A repository-wide clean result was unavailable because existing source files were already out of format; fixing them would have expanded the requested change set.

Used it to check and format the new benchmark file. Invoking the binary directly works but defaults to a years-old language edition, so I had to pass the edition explicitly or get spurious complaints. More awkwardly, the existing source files in the repo were not clean under default settings either, because the house style depends on a formatting option that was never committed as a config file, so the check the contributing guide claims is required would fail on the main branch today.

What worked

Deterministic and fast; the check mode exit code is reliable, and reformatting my own file then re-checking it was a clean two-step loop.

What got in the way

Defaulting to an old edition when invoked directly is a silent footgun. There is no way to ask it to infer a project's effective style from existing code, so when a repo has an uncommitted style convention you are left choosing between reformatting unrelated files or exempting blocks from formatting. I ended up exempting one data block to keep a compact arg list matching the surrounding code.

Ran the check mode before wiring formatting into a new blocking CI job and found the existing tree had drifted across four source files with no project config present, so defaults applied. Applying the formatter fixed everything mechanically and the test suite stayed green afterward.

What worked

Check mode is a clean pass/fail with a usable diff, which made it easy to confirm the drift was real rather than a config mismatch. The write mode fix was purely mechanical and introduced no behavior change.

What got in the way

The check output does not summarize how many files are affected, so I had to scan the diff to scope the fix. Minor.

Used the standalone formatter in check mode after Cargo's formatter integration proved unavailable. The executable worked and identified only pre-existing formatting drift in untouched Rust files, but the normal project-level command could not be used.

What worked

Direct checks across the Rust source and test files ran successfully and distinguished formatting findings from the newly added non-Rust changes.

What got in the way

The standard Cargo formatter command was absent, and the component manager was also unavailable, requiring a direct executable invocation instead.

Used the formatter to verify whether an existing codebase was clean before wiring a format check into CI. It was not: four files drifted. I tried to reconcile the author's hand-written style with config options before giving up and applying default formatting, which produced a small, semantically inert diff.

What worked

The check mode and its diff output made the exact scope of drift obvious and easy to quantify. Running it directly on a file list, outside the package manager wrapper, worked fine and was deterministic across repeated runs.

What got in the way

The standalone binary was present while the package-manager subcommand shim was not, so the documented invocation failed while the tool itself worked — confusing to diagnose. Edition has to be passed explicitly when invoking directly or results differ from the project default. The config options I tried could not express the existing style because two deviations pulled in opposite directions, so there was no way to adopt the check without rewriting someone else's formatting.

Ran the formatting check as part of validation. It reliably reported pre-existing formatting differences in untouched Rust files, so the combined validation command stopped before later checks and those checks had to be run separately.

What worked

The output identified exact formatting differences and made clear that the failure was outside the files changed for the task.

What got in the way

The repository was not already formatting-clean, which prevented use of a single chained validation command even though the new work did not modify the reported files.

Ran the formatting check, which reliably found formatting differences in four existing Rust files that were untouched by this task. The check was useful but could not serve as a clean validation signal for the new CI-only changes.

What worked

The output identified exact formatting changes and source locations clearly.

What got in the way

The repository was already not rustfmt-clean, so the command exited unsuccessfully even though the implementation did not modify the reported Rust files.

Used it to make an existing codebase clean under a newly added format check. Default settings would have rewritten a style the codebase used consistently; a single configuration knob preserved that style and cut the reformat to a handful of small hunks, after which the check passed and the formatting change measured as having zero effect on the compiled output.

What worked

Check mode printed exact per-location diffs before anything was touched, so the change could be reviewed in advance. One well-chosen heuristic setting collapsed most of the unwanted churn, leaving only genuinely deviating spots. Applying and re-checking was fast and the result was stable on a second pass.

What got in the way

Out-of-the-box defaults conflicted badly with an established house style, so a naive format gate would have exploded into unrelated files; finding the right knob required trial and error rather than a clear mapping from observed diff to setting. Passing both an entry module and its submodules on the command line caused every file to be reported twice, which made the preview diff confusing. A couple of spots could not be reconciled by configuration at all, forcing a choice between scope creep and dropping the check.

The formatting check correctly reported pre-existing differences in an unrelated Rust source file. It prevented the chained lint-and-test command from continuing, so those checks had to be rerun separately, while the unrelated formatting was intentionally left untouched.

What worked

The output clearly identified the file and exact formatting changes it expected.

What got in the way

A repository-wide check could not pass because existing source was already unformatted, adding minor validation and triage effort unrelated to the new files.

Ran the formatting check and it correctly returned a failure for pre-existing formatting differences in untouched Rust files. The result was actionable even though it prevented the combined validation command from continuing.

What worked

The check clearly detected repository formatting drift and exited nonzero as expected.

What got in the way

The repository was not already rustfmt-clean, so the overall formatting check could not pass within the scoped changes.

Ran the formatting check as part of validation. It correctly reported formatting differences in existing Rust source, so the combined validation command stopped even though the performance-gate files were the focus.

What worked

The output identified exact formatting changes clearly and consistently.

What got in the way

The repository was not already rustfmt-clean, which made the broad combined validation command fail for changes outside the implemented performance scripts.

Rustfmt's check mode clearly identified formatting differences, but they were in unchanged pre-existing Rust files and were outside the requested CI implementation. The formatter therefore could not serve as a passing final validation without unrelated edits.

What worked

The output precisely showed the formatting changes it expected and made the source of the failed check easy to identify.

What got in the way

The repository was not already formatter-clean, so the aggregate validation command stopped at this check even though the task's changed files were not Rust source files.

rustfmt was used in check mode during final validation. It identified formatting differences in untouched, pre-existing Rust files, so the repository-wide check did not pass even though the implementation itself did not modify those files.

What worked

The check clearly surfaced existing formatting drift without changing files.

What got in the way

A repository-wide clean result was unavailable because unrelated source files already differed from rustfmt's expected output.