Taskset - rust-best-practices

Goal

Evaluate Claude Code's ability to apply idiomatic Rust patterns and Apollo GraphQL's best practices when writing, reviewing, and refactoring Rust code. The agent must demonstrate understanding of ownership, error handling, performance optimization, linting, and type safety principles.

Constraints

• Must use Rust 1.70+ toolchain
• All code must pass cargo clippy --all-targets --all-features --locked -- -D warnings
• No unwrap() or expect() calls outside test code
• Must use appropriate error handling (Result<T, E> with thiserror or anyhow)
• Performance-critical code must be benchmarked with --release flag
• Must apply correct ownership patterns (borrowing vs cloning)
• All public APIs require documentation comments (///)
• Type state pattern required when encoding compile-time state safety

Tasks

Task 1: Refactor Clone-Heavy Code

Given a Rust module with excessive .clone() calls and suboptimal ownership patterns, refactor to use borrowing where appropriate. Identify which types should implement Copy, convert function signatures to accept &str/&[T] instead of owned types, and eliminate redundant clones detected by Clippy.

Files: src/parser.rs (contains string parsing with unnecessary clones)

Expected: Refactored code passing clippy::perf checks, documented rationale for remaining clones using #[expect(clippy::redundant_clone)] where justified.

Task 2: Implement Error Hierarchy with thiserror

Create a new library module with a proper error hierarchy using thiserror. Define at least three error variants with context, implement From conversions for underlying errors, and demonstrate proper error propagation using ? operator across function boundaries.

Files: Create src/errors.rs and src/validator.rs using the error types

Expected: Zero panics, all errors wrapped with context, Result<T, E> returns throughout, passes clippy error handling lints.

Task 3: Type State Pattern Implementation

Design and implement a connection state machine using the type state pattern. Must have at least three states (e.g., Disconnected, Connecting, Connected) where invalid operations are impossible at compile time. Include PhantomData usage and state transitions.

Files: Create src/connection.rs

Expected: Compile-time enforcement of state transitions, doc comments explaining design, example usage in module docs showing prevented invalid operations.

Task 4: Performance Optimization with Benchmarking

Given a module with iterator chains that prematurely call .collect(), refactor to eliminate intermediate allocations. Add criterion benchmarks comparing before/after performance, and document findings. Must apply zero-cost abstraction principles.

Files: src/processor.rs (contains nested .collect() calls), create benches/processor_bench.rs

Expected: Benchmark results showing measurable improvement, iterator fusion applied, no unnecessary heap allocations, passes clippy::perf.

Task 5: Comprehensive Code Review

Review a provided Rust module against all Apollo best practices chapters. Identify violations in: borrowing patterns, error handling, linting issues, missing documentation, suboptimal generics usage, and performance anti-patterns. Provide actionable feedback with specific chapter references and code examples.

Files: src/review_target.rs (intentionally contains multiple violations)

Expected: Markdown report listing each violation by category, severity level, chapter reference, and suggested fix with code snippet. Must catch at least 8 distinct issue types.

Acceptance Checklist

• All generated code compiles without warnings using cargo build --all-targets
• cargo clippy --all-targets --all-features --locked -- -D warnings exits successfully
• No unwrap(), expect(), or panic!() in production code paths (tests excluded)
• All public functions and types have /// documentation comments
• Error handling uses Result<T, E> with appropriate error types (thiserror or anyhow)
• Borrowing preferred over cloning with documented justification for any remaining clones
• Type state pattern correctly uses PhantomData and prevents invalid states at compile time
• Benchmarks exist and demonstrate measurable performance improvements
• Code review identifies at least 8 distinct Apollo best practice violations with chapter references
• All TODO comments include issue references (e.g., // TODO(#42): ...)
• Test names follow convention: fn operation_should_behavior_when_condition()
• Iterator chains avoid unnecessary .collect() calls between operations

Required Output Schema

{
  "task_completion": {
    "task_1_refactor": {
      "files_modified": ["src/parser.rs"],
      "clones_eliminated": 0,
      "borrowing_conversions": 0,
      "clippy_perf_pass": false
    },
    "task_2_errors": {
      "files_created": ["src/errors.rs", "src/validator.rs"],
      "error_variants_defined": 0,
      "panic_count": 0,
      "result_propagation": false
    },
    "task_3_typestate": {
      "files_created": ["src/connection.rs"],
      "states_defined": 0,
      "compile_time_safety": false,
      "phantom_data_used": false
    },
    "task_4_performance": {
      "files_modified": ["src/processor.rs"],
      "files_created": ["benches/processor_bench.rs"],
      "intermediate_collections_removed": 0,
      "performance_improvement_percent": 0.0,
      "benchmark_exists": false
    },
    "task_5_review": {
      "files_reviewed": ["src/review_target.rs"],
      "violations_found": 0,
      "categories_covered": [],
      "chapter_references": 0,
      "report_generated": false
    }
  },
  "acceptance_criteria": {
    "compiles_without_warnings": false,
    "clippy_passes": false,
    "no_unwrap_in_prod": false,
    "all_public_documented": false,
    "proper_error_handling": false,
    "borrowing_optimized": false,
    "typestate_correct": false,
    "benchmarks_demonstrate_improvement": false,
    "review_comprehensive": false,
    "todos_have_issues": false,
    "test_naming_convention": false,
    "iterator_optimization": false
  },
  "clippy_report": {
    "warnings": 0,
    "errors": 0,
    "perf_issues": 0,
    "correctness_issues": 0
  },
  "documentation_coverage": {
    "public_items": 0,
    "documented_items": 0,
    "coverage_percent": 0.0
  }
}