Rust-Eze Debugger

Advanced Rust code analysis and correction system designed for Cursor IDE. This skill provides comprehensive error prevention, code quality enforcement, and systematic debugging for Rust projects using Cargo toolchain integration.

What This Skill Does

This skill transforms Cursor into a powerful Rust development environment with:

**Multi-stage validation**: Runs `cargo check`, `cargo clippy`, `cargo test`, and `cargo fmt` in priority order

**Error prevention**: Validates changes before and after modifications to prevent introducing new errors

**Code quality enforcement**: Enforces Rust best practices, naming conventions, and documentation standards

**Implementation-first approach**: Prefers implementing uses for unused code over removal

**Comprehensive documentation**: All documentation in Chinese with detailed rationale and examples

Instructions for the AI Agent

Core Behavior

1. **Terminal Environment**: Assume Windows PowerShell environment

2. **Direct Guidance**: Provide direct solutions without asking questions

3. **Error Resolution Focus**: Prioritize fixing errors over cosmetic changes

4. **No New Errors**: Never introduce new errors while fixing existing ones

5. **Preserve Functionality**: Maintain all existing functionality during refactoring

6. **Implement Over Remove**: Always prefer implementing uses for code over removing it

Validation Workflow

Execute commands in strict priority order:

1. **Priority 1 - Build Errors**: `cargo check`

- Run before making any changes

- Run after each change

- Must pass before proceeding

2. **Priority 2 - Safety Issues**: `cargo clippy`

- Fix warnings and denials

- Suggest actionable improvements

- Address common mistakes

3. **Priority 3 - Test Failures**: `cargo test`

- Run unit, integration, and doc tests

- Ensure no regressions

- Validate all changes

4. **Priority 4 - Style**: `cargo fmt -- --check`

- Check formatting consistency

- Follow Rustfmt guidelines

- Maintain readability

Error Handling Strategy

**Error Prevention Checks**:

Verify type compatibility before changes

Check ownership implications

Validate scope and visibility changes

Ensure trait bounds are satisfied

Compile-check after each modification

**Pre-Implementation Analysis**:

Analyze dependencies and downstream impacts

Check trait coherence

Validate type bounds

Verify memory and thread safety

Ensure async safety

**Implementation Guards**:

Prevent partial implementations

Ensure exhaustive pattern matching

Verify complete error handling

Check proper resource cleanup

Handling Unused Imports

**Strategy**: Implement or justify, never just remove

For each unused import, choose one approach:

1. **Type Implementations**:

- Create wrapper types

- Implement common traits (Debug, Clone, Display, etc.)

- Add type conversions (From, Into, TryFrom, TryInto)

2. **Function Implementations**:

- Create utility functions using the import

- Add test coverage demonstrating usage

- Implement usage examples

3. **Module Implementations**:

- Create feature modules utilizing the import

- Implement module tests

- Add integration examples

4. **Justification**: If truly unused, document why removal is appropriate

Code Refinement Rules

**Constants Organization**:

Place immediately below imports

Use SCREAMING_SNAKE_CASE naming

Add descriptive prefixes: `TIMEOUT_`, `MAX_`, `MIN_`, `DEFAULT_`

Group by purpose: configuration → business logic → errors → defaults

Document with `// {description}` including units and rationale

**Magic Numbers**:

Detect all hardcoded numbers

Replace with named constants using pattern: `{PURPOSE}_{UNIT}`

Relocate to constants section

Update all references

**Error Handling Patterns**:

Prefer `Result<T, E>` over panic

Create custom error types per module

Implement `std::error::Error` trait

Use `?` operator for propagation

Add context to errors

Documentation Requirements

**Language**: All documentation must be in Chinese (中文)

**Required Sections** for all public items:

**目的 (Purpose)**: What the item does

**参数 (Parameters)**: All parameters with types and descriptions

**返回值 (Returns)**: Return type and meaning

**恐慌 (Panics)**: When and why panics occur

**安全性 (Safety)**: Safety guarantees (for unsafe code)

**错误 (Errors)**: Error conditions and types

**示例 (Examples)**: Usage examples with code

**Implementation Documentation**:

Code context explanation

Implementation rationale

Alternatives considered

Performance implications

Memory considerations

Threading implications

Safety guarantees

**Change Documentation Format**:

```rust

// 修改内容:

// - 错误: [list of errors fixed]

// - 更改: [list of changes made]

// - 原因: [rationale for changes]

// - 性能影响: [optional performance implications]

// - 安全性影响: [optional safety implications]

```

**Inline Comments**:

Format: `// {explanation in Chinese}`

Explain non-obvious logic

Clarify complex algorithms

Response Format

When providing code suggestions:

Use minimal Rust code blocks with exactly two backticks

Format: `` ```rust `` (opening) and `` ``` `` (closing)

No additional code blocks in the same response

Avoid markdown headers, asterisks, or other symbols

Maintain proper indentation

Preserve all comments

Module Referencing Patterns

**Reference Prefix**: Use `(at)` to reference modules

Examples: `(at)module.rs`, `(at)lib.rs`, `(at)mod.rs`

**Import Syntax**:

```rust

use crate::...; // Absolute from crate root

pub use::...; // Re-export

use super::...; // Parent module

use self::...; // Current module

```

**Module Definitions**:

```rust

mod {name}; // Private module

pub mod {name}; // Public module

mod {name} { ... } // Inline module

```

Analysis Coverage

**Static Analysis**:

Lint checks via Clippy

Unsafe code detection

Dead code detection

Complexity metrics

Dependency analysis

**Semantic Analysis**:

Type inference validation

Borrow checker verification

Lifetime validation

Trait resolution

Argument matching

**Optimization Analysis**:

Performance improvement suggestions

Memory optimization opportunities

Code organization improvements

Import optimization

Safety Requirements

**Unsafe Code**:

Require justification for all `unsafe` blocks

Document all risks and invariants

Explain safety guarantees

Prefer safe alternatives when available

**Error Handling**:

Prefer `Result` over `panic!`

Require custom error types

Document all failure cases

Use `?` operator for propagation

Validation After Fixes

After applying any fix:

1. Run `cargo check` - must pass

2. Run `cargo clippy` - address all warnings

3. Run `cargo test` - all tests must pass

4. Verify no new errors introduced

5. Ensure no functionality regressions

Recommendations Per Error

For each error, provide:

Minimum 2 recommendations

Maximum 5 recommendations

All recommendations must be actionable

Use proper Rust syntax

Maintain existing code style

Preserve documentation

Consider dependencies

Utilize unused imports if beneficial

Example Usage

**Scenario**: Fixing compilation errors in a Rust project

1. Agent runs `cargo check` and identifies 5 build errors

2. Agent analyzes root causes: 3 type mismatches, 1 missing import, 1 unused import

3. For unused import, agent implements a utility function using it

4. Agent fixes type mismatches with proper conversions

5. Agent adds missing import with proper module path

6. Agent documents all changes in Chinese

7. Agent runs validation: `cargo check` → `cargo clippy` → `cargo test` → `cargo fmt`

8. Agent confirms no new errors introduced

Constraints

Must use Windows PowerShell syntax for commands

All documentation must be in Chinese (中文)

Never remove code without implementing alternative uses first

Always validate changes don't introduce new errors

Maintain existing code organization and style

Respect project's rustfmt settings

Follow priority order for error fixes: build → safety → tests → style

Rust-Eze Debugger

Rust-Eze Debugger

What This Skill Does

Instructions for the AI Agent

Core Behavior

Validation Workflow

Error Handling Strategy

Handling Unused Imports

Code Refinement Rules

Documentation Requirements

Response Format

Module Referencing Patterns

Analysis Coverage

Safety Requirements

Validation After Fixes

Recommendations Per Error

Example Usage

Constraints

Reviews (0)