rust-quality-checker（Rust quality checker 搜索）

Rust Quality Checker Skill

Purpose

This skill provides comprehensive Rust code quality validation including formatting (rustfmt), linting (clippy), compilation checks (cargo check), testing (cargo test), security analysis (cargo audit), and best practices validation. Ensures code meets Rust idioms and project standards.

When to Use

• Validating Rust code quality before commit
• Running pre-commit quality checks
• CI/CD quality gate validation
• Code review preparation
• Ensuring idiomatic Rust code
• Security vulnerability detection
• Performance optimization validation

Quality Check Workflow

1. Environment Setup

Verify Rust Toolchain:

# Check Rust version
rustc --version

# Check Cargo version
cargo --version

# Check rustfmt
rustfmt --version

# Check clippy
cargo clippy --version

Install/Update Components:

# Update Rust toolchain
rustup update

# Install rustfmt (if not present)
rustup component add rustfmt

# Install clippy (if not present)
rustup component add clippy

# Install cargo-audit for security checks
cargo install cargo-audit

# Install cargo-tarpaulin for coverage
cargo install cargo-tarpaulin

Deliverable: Rust toolchain ready

2. Code Formatting Check (rustfmt)

Check Formatting:

# Check if code is formatted
cargo fmt -- --check

# Check with edition
cargo fmt --edition 2021 -- --check

# Check specific files
rustfmt --check src/main.rs

# Check with verbose output
cargo fmt --verbose -- --check

Auto-Format Code:

# Format all code
cargo fmt

# Format with specific edition
cargo fmt --edition 2021

# Format specific file
rustfmt src/main.rs

Configuration (rustfmt.toml):

# rustfmt.toml
edition = "2021"
max_width = 100
hard_tabs = false
tab_spaces = 4
newline_style = "Unix"
use_small_heuristics = "Default"
reorder_imports = true
reorder_modules = true
remove_nested_parens = true
fn_single_line = false
where_single_line = false
imports_granularity = "Crate"
group_imports = "StdExternalCrate"

Deliverable: Formatting validation report

3. Compilation Check (cargo check)

Fast Compilation Check:

# Basic check
cargo check

# Check with all features
cargo check --all-features

# Check workspace
cargo check --workspace

# Check specific package
cargo check --package my-package

# Check with verbose output
cargo check --verbose

Full Compilation:

# Build project
cargo build

# Build in release mode
cargo build --release

# Build with all features
cargo build --all-features

# Build all targets
cargo build --all-targets

Deliverable: Compilation status report

4. Linting (clippy)

Run Clippy:

# Basic clippy check
cargo clippy

# Deny all warnings
cargo clippy -- -D warnings

# Pedantic mode (strictest)
cargo clippy -- -W clippy::pedantic

# All clippy lints
cargo clippy -- -W clippy::all

# Nursery lints (unstable but useful)
cargo clippy -- -W clippy::nursery

# Check workspace
cargo clippy --workspace

Clippy with Auto-Fix:

# Fix clippy suggestions
cargo clippy --fix

# Fix with deny warnings
cargo clippy --fix -- -D warnings

Configuration (clippy.toml or.clippy.toml):

# clippy.toml
msrv = "1.70"  # Minimum Supported Rust Version

# Allow certain lints
allow = [
    "clippy::module_name_repetitions",
]

# Warn on these
warn = [
    "clippy::all",
    "clippy::pedantic",
    "clippy::cargo",
]

# Deny these
deny = [
    "clippy::unwrap_used",
    "clippy::expect_used",
    "clippy::panic",
]

Deliverable: Clippy lint report

5. Testing (cargo test)

Run Tests:

# Run all tests
cargo test

# Run with verbose output
cargo test -- --nocapture

# Run specific test
cargo test test_name

# Run tests in specific module
cargo test module::test_name

# Run doc tests only
cargo test --doc

# Run with all features
cargo test --all-features

Test with Coverage:

# Install tarpaulin
cargo install cargo-tarpaulin

# Generate coverage
cargo tarpaulin --out Html --out Xml

# Coverage with threshold
cargo tarpaulin --fail-under 80

# Coverage for workspace
cargo tarpaulin --workspace

Deliverable: Test execution and coverage report

6. Security Analysis (cargo audit)

Dependency Security Check:

# Install cargo-audit
cargo install cargo-audit

# Run security audit
cargo audit

# Audit with JSON output
cargo audit --json

# Audit and fix vulnerabilities
cargo audit fix

# Check for yanked crates
cargo audit --deny yanked

Update Dependencies:

# Install cargo-outdated
cargo install cargo-outdated

# Check for outdated dependencies
cargo outdated

# Update dependencies
cargo update

# Update specific dependency
cargo update -p dependency-name

Deliverable: Security audit report

7. Dependency Analysis

Check Dependency Tree:

# Show dependency tree
cargo tree

# Show dependencies for specific package
cargo tree --package my-package

# Show duplicates
cargo tree --duplicates

# Show dependencies with specific features
cargo tree --features feature-name

# Invert tree (show reverse dependencies)
cargo tree --invert

Check Unused Dependencies:

# Install cargo-udeps
cargo install cargo-udeps

# Find unused dependencies
cargo +nightly udeps

Deliverable: Dependency analysis report

8. Code Quality Checks

Check for Unsafe Code:

# Find unsafe blocks
grep -r "unsafe" src/

# Count unsafe blocks
grep -r "unsafe" src/ | wc -l

# Use cargo-geiger for unsafe usage report
cargo install cargo-geiger
cargo geiger

Check Documentation:

# Build documentation
cargo doc

# Check for missing docs
cargo rustdoc -- -D missing_docs

# Check documentation tests
cargo test --doc

Deliverable: Code quality assessment

9. Performance Analysis

Benchmark Tests:

# Run benchmarks
cargo bench

# Run specific benchmark
cargo bench benchmark_name

# Use criterion for better benchmarks
# Add to Cargo.toml:
# [dev-dependencies]
# criterion = "0.5"
cargo bench

Performance Profiling:

# Build with release mode
cargo build --release

# Use flamegraph
cargo install flamegraph
cargo flamegraph

# Use perf (Linux)
perf record --call-graph dwarf ./target/release/binary
perf report

Deliverable: Performance analysis report

10. Comprehensive Quality Check

Run All Checks:

#!/bin/bash
# scripts/quality-check.sh

set -e  # Exit on first error

echo "=== Rust Quality Checks ==="

echo "1. Code Formatting (rustfmt)..."
cargo fmt -- --check

echo "2. Compilation Check..."
cargo check --workspace

echo "3. Linting (clippy)..."
cargo clippy --workspace -- -D warnings

echo "4. Testing..."
cargo test --workspace

echo "5. Documentation Check..."
cargo doc --no-deps --document-private-items

echo "6. Security Audit..."
cargo audit

echo "7. Unused Dependencies..."
cargo +nightly udeps || true  # Don't fail build

echo "=== All Quality Checks Passed ✅ ==="

Makefile Integration:

# Makefile
.PHONY: check fmt lint test quality

check:
	cargo check --workspace

fmt:
	cargo fmt

fmt-check:
	cargo fmt -- --check

lint:
	cargo clippy --workspace -- -D warnings

test:
	cargo test --workspace

quality: fmt-check check lint test
	@echo "All quality checks passed ✅"

Deliverable: Comprehensive quality report

Quality Standards

Code Formatting

• All code formatted with rustfmt
• Consistent use of Rust style guide
• Proper module organization
• Imports properly grouped
• Line length ≤ 100 characters

Compilation

• Code compiles without errors
• No compiler warnings
• All features compile
• Documentation builds
• All targets build

Linting

• No clippy warnings (with -D warnings)
• Pedantic lints addressed
• No unwrap/expect in production code
• Proper error handling
• No panic! in library code

Testing

• All tests passing
• Coverage ≥ 80%
• Doc tests passing
• Integration tests passing
• No ignored tests (without reason)

Security

• No known vulnerabilities
• Dependencies up to date
• No yanked crates
• Minimal unsafe code
• Unsafe code documented

Code Quality

• Idiomatic Rust code
• Proper lifetime annotations
• Efficient error handling
• Documentation complete
• Examples provided

Quality Check Matrix

Pre-commit Integration

Setup Git Hooks:

#!/bin/bash
# .git/hooks/pre-commit

echo "Running Rust quality checks..."

# Format check
if ! cargo fmt -- --check; then
    echo "❌ Code not formatted. Run: cargo fmt"
    exit 1
fi

# Clippy
if ! cargo clippy -- -D warnings; then
    echo "❌ Clippy warnings found"
    exit 1
fi

# Tests
if ! cargo test --quiet; then
    echo "❌ Tests failed"
    exit 1
fi

echo "✅ All pre-commit checks passed"

Make hook executable:

chmod +x .git/hooks/pre-commit

Deliverable: Pre-commit hooks configured

CI/CD Integration

GitHub Actions Example:

# .github/workflows/rust-quality.yml
name: Rust Quality Checks

on: [push, pull_request]

env:
  CARGO_TERM_COLOR: always

jobs:
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
          toolchain: stable
          components: rustfmt, clippy
          override: true

      - name: Cache cargo registry
        uses: actions/cache@v3
        with:
          path: ~/.cargo/registry
          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}

      - name: Check formatting
        run: cargo fmt -- --check

      - name: Check compilation
        run: cargo check --workspace

      - name: Run clippy
        run: cargo clippy --workspace -- -D warnings

      - name: Run tests
        run: cargo test --workspace --verbose

      - name: Check documentation
        run: cargo doc --no-deps --document-private-items

      - name: Security audit
        run: |
          cargo install cargo-audit
          cargo audit

      - name: Generate coverage
        run: |
          cargo install cargo-tarpaulin
          cargo tarpaulin --out Xml --fail-under 80

      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./cobertura.xml

Deliverable: CI/CD quality pipeline

Quality Check Troubleshooting

rustfmt Formatting Failures

# Check what would change
cargo fmt -- --check

# Apply formatting
cargo fmt

# Check specific file
rustfmt --check src/main.rs

Compilation Errors

# Check with verbose output
cargo check --verbose

# Clean and rebuild
cargo clean
cargo check

# Check dependencies
cargo tree

Clippy Warnings

# Show detailed warnings
cargo clippy -- -W clippy::all

# Auto-fix suggestions
cargo clippy --fix

# Ignore specific warning (last resort)
#[allow(clippy::warning_name)]

Test Failures

# Run with verbose output
cargo test -- --nocapture

# Run specific test
cargo test test_name -- --exact

# Show test output
cargo test -- --show-output

Quality Report Template

# Rust Quality Check Report

## Summary
- **Status**: ✅ All checks passed
- **Date**: 2024-01-15
- **Project**: my-rust-project

## Checks Performed

### Formatting (rustfmt)
- **Status**: ✅ PASS
- **Files Checked**: 42
- **Issues**: 0

### Compilation (cargo check)
- **Status**: ✅ PASS
- **Workspace**: All packages compile
- **Warnings**: 0

### Linting (clippy)
- **Status**: ✅ PASS
- **Warnings**: 0
- **Pedantic**: Enabled

### Testing (cargo test)
- **Status**: ✅ PASS
- **Tests**: 156 passed
- **Doc Tests**: 23 passed

### Coverage (tarpaulin)
- **Status**: ✅ PASS
- **Coverage**: 87% (target: 80%)

### Security (cargo audit)
- **Status**: ✅ PASS
- **Vulnerabilities**: 0
- **Yanked Crates**: 0

### Documentation
- **Status**: ✅ PASS
- **Docs Build**: Success
- **Missing Docs**: 0

## Details

All Rust quality checks passed successfully. Code is well-formatted, compiles cleanly, passes all lints, has good test coverage, and is secure.

## Recommendations

- Continue maintaining high test coverage
- Keep dependencies updated
- Document all public APIs
- Minimize unsafe code usage

Integration with Code Quality Specialist

Input: Rust codebase quality check request Process: Run all Rust quality tools and analyze results Output: Comprehensive quality report with pass/fail status Next Step: Report to code-quality-specialist for consolidation

Best Practices

Development

• Run cargo fmt on save (IDE integration)
• Enable clippy in IDE for real-time feedback
• Use cargo watch for continuous checking
• Fix warnings immediately

Pre-Commit

• Run full quality check script
• Ensure all tests pass
• Verify no clippy warnings
• Check documentation builds

CI/CD

• Run quality checks on every PR
• Fail build on warnings
• Generate coverage reports
• Track quality metrics over time
• Cache dependencies for speed

Code Review

• Verify quality checks passed
• Review clippy suggestions
• Check test coverage
• Validate unsafe code usage

Supporting Resources

• Rust Book: https://doc.rust-lang.org/book
• rustfmt: https://rust-lang.github.io/rustfmt
• clippy: https://rust-lang.github.io/rust-clippy
• cargo audit: https://github.com/rustsec/rustsec
• tarpaulin: https://github.com/xd009642/tarpaulin

Success Metrics

• All code formatted with rustfmt
• Compilation passes with no warnings
• Zero clippy warnings
• All tests passing
• Coverage ≥ 80%
• No security vulnerabilities
• Documentation complete