rust-quality

Target

$ARGUMENTS

---

Audit Rust code quality. Report issues in organized format, then offer to fix.

Audit Categories

1. Clippy Violations

• All clippy warnings must be addressed, not silenced
• Use #[expect(...)] with comment if truly necessary, never bare #[allow(...)]
• Check for missing workspace lint config in Cargo.toml

2. Borrowing & Cloning

Red flags:

• .clone() inside loops - use .cloned() or .copied() on iterator
• .clone() on large types (Vec<T>, HashMap<K,V>)
• Clone when borrow would work - fn process(s: String) vs fn process(s: &str)
• &Vec<T> instead of &[T]
• &String instead of &str
• Cloning reference args when caller should pass ownership

Prefer:

• Borrow over clone
• &str over String in params
• &[T] over &Vec<T> in params
• impl AsRef<T> for flexible APIs

3. Option/Result Handling

Red flags:

• .unwrap() or .expect() in non-test code
• match for simple Ok/Err -> Some/None conversions (use .ok(), .ok_or())
• Manual match that could be let Ok(x) = expr else { return }
• if let Some(x) = ... { x } else { default } instead of .unwrap_or()

Prefer:

• ? for error propagation
• let Ok(x) = expr else { return Err(...) } for early returns
• .ok_or_else() / .map_or_else() when allocation needed
• thiserror for library errors, anyhow only for binaries

4. Iterator Patterns

Red flags:

• Collecting just to iterate again - .collect::<Vec<_>>() then for x in vec
• Manual loops that could be .filter().map().collect()
• .fold() for simple sums (use .sum())
• Missing .iter() vs .into_iter() awareness (prefer .iter() for Copy types)

Prefer:

• Pass iterators directly when possible
• Lazy evaluation - don't collect until needed
• .enumerate() over manual index tracking

5. Error Handling

Red flags:

• panic! in library code (use Result)
• Box<dyn Error> in library APIs (use thiserror)
• Missing # Errors doc section on fallible functions
• anyhow in library code

Prefer:

• thiserror with descriptive error variants
• Error hierarchies with #[from] for wrapping
• ? over verbose match chains
• inspect_err() for logging

6. Performance Anti-patterns

Red flags:

• Unnecessary heap allocation (Box when stack works)
• #[inline] without benchmark proof
• Large stack allocations (arrays > 64KB)
• Box<dyn Trait> when impl Trait works
• Early allocation in or, map_or, unwrap_or (use _else variants)

Prefer:

• impl Trait (static dispatch) over dyn Trait when possible
• Cow<'_, str> for maybe-owned data
• Benchmark before optimizing

7. Comments & Documentation

Red flags:

• Comments explaining "what" not "why"
• // TODO without issue link
• Stale/misleading comments
• Missing /// docs on public items
• Missing # Examples, # Errors, # Panics sections

Prefer:

• Let code speak - extract functions over comments
• Link to ADRs/issues for context
• Doc tests as living examples

8. Type System

Red flags:

• Runtime state checks that could be compile-time (type state pattern)
• Option<T> fields for required builder params
• Missing #[non_exhaustive] on public enums
• dyn Trait without Send + Sync in async contexts

Prefer:

• Type state pattern for state machines
• Compile-time guarantees over runtime checks
• PhantomData for zero-cost type markers

9. Rust Slop (AI/verbose cruft)

Red flags:

• Defensive code for impossible cases
• Over-engineered abstractions for one-time use
• Verbose intermediate variables adding nothing
• Interfaces with single implementations
• Factory patterns for simple construction

Output Format

# Rust Quality Audit: [path]

## Critical (must fix)
- [file:line] Category: Description

## Warnings (should fix)
- [file:line] Category: Description

## Suggestions (consider)
- [file:line] Category: Description

## Summary
- X critical, Y warnings, Z suggestions
- Key patterns to address: ...

After reporting, ask: "Fix issues? (all / critical only / skip)"