---

name: review-and-fix description: Deep analysis and iterative fixing of a Rust source file. Finds logic errors, lock/concurrency issues, and simplification opportunities, then fixes them one by one until the file is clean.

review-and-fix

Deep-analyze the specified file, find logic errors, memory/lock issues, and simplification opportunities, and fix them iteratively until no problems remain.

Usage

/review-and-fix <file_path>

Examples

/review-and-fix src/mqtt-broker/src/subscribe/buckets.rs
/review-and-fix src/mqtt-broker/src/subscribe/directly_push.rs

Execution Flow

Each round follows this sequence until nothing left to fix:

1. Read

Fully read the target file. Read related files as needed (callers, struct definitions it depends on) to understand context.

2. Analyze

Check in priority order:

Logic Errors (must fix)

• Asymmetric data structure operations: add writes N indexes, remove only cleans N-1
• offset/commit semantics: committing after push failure causes message loss
• Key collisions: separator choice produces identical keys for different inputs

Concurrency/Lock Issues (must fix)

• DashMap entry(), get(), get_mut() return Ref/RefMut that hold shard locks — not released during .await
• RwLock read lock held during .await blocks write lock
• Fix: .clone() the data to drop the guard before awaiting; or store Arc<T>

Simplification (apply judiciously)

• Repeated get_mut + else { insert } → entry().or_default()
• Redundant else { return x } → remove the else
• Two-step let x = ...; let x = match x { Some(v) => v, None => return } → let Some(x) = ... else { return }
• Nested if !condition { ... } → if condition { continue }
• Duplicate import lines → merge
• Temporary flag variables (let mut failed = false; ... if !failed { commit() }) → early return

Comments (keep lean)

• Remove redundant or obvious comments; the code should speak for itself
• Keep only comments that explain a non-obvious why (an invariant, a subtle ordering, a footgun)
• Do not over-comment — fewer, higher-signal comments beat many noisy ones

Test Cases (deep review, then trim — do not just add)

• Deep-review every existing test before adding anything: does it assert a real behavior, or just re-exercise the happy path another test already covers? Does the assertion actually fail if the logic under test is broken (mutate the code mentally and check)?
• Default action is consolidation, not addition: merge near-duplicate tests into one parametrized/table-driven case, delete tests that assert trivial defaults or that duplicate coverage another test already provides
• Only add a new test when a real gap exists: a pure decision function or bug-prone branch with zero coverage. One targeted case per gap — do not pad with variations that don't exercise a new path
• Prefer testing the pure/extractable logic directly over standing up heavy mocks for orchestration glue; if a path can only be tested by mocking a large dependency, that's usually a sign to extract the pure logic rather than write the mock
• Keep the total test count as small as possible while still covering every distinct branch/outcome once — "few, focused, high-signal" beats "thorough-looking"

Naming (align names with behavior)

• Function names: does the name describe what the function actually does? Rename misleading or vague names (e.g. a get_* that mutates, a *_switch that only computes)
• File / module names: does the file name match its content and responsibility? Flag/rename when it has drifted
• When renaming, update every reference (callers, imports, mod declarations) and re-run cargo check. Be conservative with widely-used public names — only rename when the current name is genuinely misleading, not for taste

What NOT to do

• Do not refactor correct code just to be "more Rusty"
• Do not introduce new abstractions or traits
• Do not change public API signatures (unless there is a bug, or a name is genuinely misleading — then rename and update all call sites)
• Do not add unnecessary comments

3. Fix

• Only fix issues you are certain about — do not guess
• After each fix, run cargo check -p <crate> to verify compilation
• For core logic changes, run the relevant unit tests

4. Loop

After each round of fixes, re-analyze the file to confirm nothing was missed. Stop only when you can clearly state: "no logic errors, no lock issues, no worthwhile simplification remaining, names match behavior, test coverage adequate and focused, comments lean."

Output Format

• Start each round by stating what problems were found
• After fixing, explain what changed and why
• On the final round, explicitly state "no issues, stopping"
• Do not output meaningless progress descriptions