Rust Trait Explorer

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Explore Rust trait implementations using LSP. Triggers on: /trait-impl, find implementations, who implements, trait 实现, 谁实现了, 实现了哪些trait

Instructions onlySoftware Development
AI-generated overview

Explores Rust trait implementations and type-trait relationships using LSP navigation and grep.

What it does
The skill guides an agent through locating a Rust trait or struct definition, then finding its implementations or implemented traits using LSP operations such as goToImplementation and documentSymbol, plus grep for impl blocks. It produces structured reports: implementor tables with locations, implementation details, trait lists grouped by origin, hierarchy diagrams, coverage checks, and blanket implementation notes.
When to use it
Use it when asked who implements a given Rust trait, which traits a type implements, or how a trait hierarchy is structured. It also suits coverage checks and understanding polymorphic designs in a Rust codebase.
Requirements
Requires an LSP tool for Rust, plus Read, Glob and Grep access to the project source. No scripts are shipped; it is instructions only.

Rust Trait Explorer

Discover trait implementations and understand polymorphic designs.

Usage

/rust-trait-explorer <TraitName|StructName>

Examples:

  • /rust-trait-explorer Handler - Find all implementors of Handler trait
  • /rust-trait-explorer MyStruct - Find all traits implemented by MyStruct

LSP Operations

Go to Implementation

Find all implementations of a trait.

LSP(  operation: "goToImplementation",  filePath: "src/traits.rs",  line: 10,  character: 11)

Use when:

  • Trait name is known
  • Want to find all implementors
  • Understanding polymorphic code

Workflow

Find Trait Implementors

User: "Who implements the Handler trait?"    │    ▼[1] Find trait definition    LSP(goToDefinition) or workspaceSymbol    │    ▼[2] Get implementations    LSP(goToImplementation)    │    ▼[3] For each impl, get details    LSP(documentSymbol) for methods    │    ▼[4] Generate implementation map

Find Traits for a Type

User: "What traits does MyStruct implement?"    │    ▼[1] Find struct definition    │    ▼[2] Search for "impl * for MyStruct"    Grep pattern matching    │    ▼[3] Get trait details for each    │    ▼[4] Generate trait list

Output Format

Trait Implementors

## Implementations of `Handler`
**Trait defined at:** src/traits.rs:15
​```rustpub trait Handler {    fn handle(&self, request: Request) -> Response;    fn name(&self) -> &str;}​```
### Implementors (4)
| Type | Location | Notes ||------|----------|-------|| AuthHandler | src/handlers/auth.rs:20 | Handles authentication || ApiHandler | src/handlers/api.rs:15 | REST API endpoints || WebSocketHandler | src/handlers/ws.rs:10 | WebSocket connections || MockHandler | tests/mocks.rs:5 | Test mock |
### Implementation Details
#### AuthHandler​```rustimpl Handler for AuthHandler {    fn handle(&self, request: Request) -> Response {        // Authentication logic    }
    fn name(&self) -> &str {        "auth"    }}​```
#### ApiHandler​```rustimpl Handler for ApiHandler {    fn handle(&self, request: Request) -> Response {        // API routing logic    }
    fn name(&self) -> &str {        "api"    }}​```

Traits for a Type

## Traits implemented by `User`
**Struct defined at:** src/models/user.rs:10
### Standard Library Traits| Trait | Derived/Manual | Notes ||-------|----------------|-------|| Debug | #[derive] | Auto-generated || Clone | #[derive] | Auto-generated || Default | manual | Custom defaults || Display | manual | User-friendly output |
### Serde Traits| Trait | Location ||-------|----------|| Serialize | #[derive] || Deserialize | #[derive] |
### Project Traits| Trait | Location | Methods ||-------|----------|---------|| Entity | src/db/entity.rs:30 | id(), created_at() || Validatable | src/validation.rs:15 | validate() |
### Implementation Hierarchy
​```User├── derive│   ├── Debug│   ├── Clone│   ├── Serialize│   └── Deserialize└── impl    ├── Default (src/models/user.rs:50)    ├── Display (src/models/user.rs:60)    ├── Entity (src/models/user.rs:70)    └── Validatable (src/models/user.rs:85)​```

Trait Hierarchy Visualization

## Trait Hierarchy
                    ┌─────────────┐                    │    Error    │ (std)                    └──────┬──────┘                           │              ┌────────────┼────────────┐              │            │            │      ┌───────▼───────┐ ┌──▼──┐ ┌───────▼───────┐      │  AppError     │ │ ... │ │  DbError      │      └───────┬───────┘ └─────┘ └───────┬───────┘              │                         │      ┌───────▼───────┐         ┌───────▼───────┐      │ AuthError     │         │ QueryError    │      └───────────────┘         └───────────────┘

Analysis Features

Coverage Check

## Trait Implementation Coverage
Trait: Handler (3 required methods)
| Implementor | handle() | name() | priority() | Complete ||-------------|----------|--------|------------|----------|| AuthHandler | ✅ | ✅ | ✅ | Yes || ApiHandler | ✅ | ✅ | ❌ default | Yes || MockHandler | ✅ | ✅ | ✅ | Yes |

Blanket Implementations

## Blanket Implementations
The following blanket impls may apply to your types:
| Trait | Blanket Impl | Applies To ||-------|--------------|------------|| From<T> | `impl<T> From<T> for T` | All types || Into<U> | `impl<T, U> Into<U> for T where U: From<T>` | Types with From || ToString | `impl<T: Display> ToString for T` | Types with Display |

Common Patterns

User SaysAction
"Who implements X?"goToImplementation on trait
"What traits does Y impl?"Grep for impl * for Y
"Show trait hierarchy"Find super-traits recursively
"Is X: Send + Sync?"Check std trait impls

Related Skills

WhenSee
Navigate to implrust-code-navigator
Call relationshipsrust-call-graph
Project structurerust-symbol-analyzer
Safe refactoringrust-refactor-helper

Source and attribution

Source:actionbook/rust-skillsinskills/rust-trait-explorerat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal