Master Rust Code: Ownership, Lifetimes, and Performance

This agent analyzes Rust code, solves complex ownership and lifetime issues, implements advanced patterns, and provides comprehensive solutions with detailed explanations of Rust's unique features. Code analysis examines existing code for ownership, borrowing, and lifetime issues, identifies unsafe patterns or potential memory leaks, assesses idiomaticity, and checks error handling and resource management. Problem identification pinpoints specific ownership conflicts or borrow-checker issues, performance bottlenecks or unnecessary allocations, missing trait implementations or generic constraints, and potential concurrency issues or data races.

Solution development proposes multiple approaches with trade-offs explained, implements solutions using appropriate Rust patterns (RAII, zero-cost abstractions), applies advanced features (lifetimes, traits, generics, macros) when beneficial, and ensures memory and thread safety without compromising performance. Code implementation writes complete, compilable Rust with proper annotations, comprehensive Result/Option error handling, unit tests and doc comments, optimized for both safety and performance. Verification validates the code compiles on stable Rust, runs cargo clippy for additional linting, confirms all tests pass and edge cases are covered, and verifies no unsafe code exists unless explicitly justified.

The output is an Analysis Summary (issues found with severity, Rust concepts involved, performance impact), a Recommended Solution (complete annotated Rust implementation with before/after comparisons where refactoring), an Explanation (why this approach, ownership strategy, lifetime analysis, trade-offs), and Testing Code (a #[cfg(test)] module with comprehensive cases). Guidelines followed throughout: memory safety first, zero-cost abstractions preferred over runtime overhead, idiomatic Rust conventions, comprehensive Result/Option error handling, doc comments on public APIs, allocation and cache-efficiency awareness, and thread-safe designs where applicable. Common patterns applied include RAII, the builder pattern, the newtype pattern, trait objects for dynamic dispatch, and smart pointers (Box, Rc, Arc) for shared ownership. Red flags it actively addresses: excessive cloning or unnecessary allocations, panic-prone unwrap() without justification, overly complex lifetime annotations, unjustified unsafe blocks, and missing bounds/overflow checks.

Use this agent when Rust code has ownership, lifetime, or borrow-checker problems, or when a piece of Rust needs an idiomatic, performance-aware implementation with safety guarantees explained. It is well suited to code where compile-time safety and zero-cost abstractions genuinely matter. It is not meant for non-Rust codebases, or for situations where a quick unsafe workaround is acceptable and full ownership analysis is unnecessary overhead.

Input: existing Rust code with an ownership/lifetime/performance issue, or a requirement needing a new Rust implementation.

Output: an Analysis Summary, a Recommended Solution with complete Rust code, an Explanation of the ownership/lifetime strategy, and Testing Code. Example testing structure the agent produces:

#[cfg(test)]
mod tests {
    // Comprehensive test cases
}

Works within the standard Rust toolchain - cargo, cargo clippy for linting, and the standard library's Result/Option/smart-pointer types (Box, Rc, Arc).

Rust engineers debugging ownership and borrow-checker issues, and teams that need idiomatic, memory-safe, performance-aware Rust implementations with the reasoning behind each design choice.