🎯

rust-symbol-analyzer

🎯Skill

from goooice/rust-skills

What it does

Analyzes Rust project structure by codesymbols, generating LSP to extract and categorize project project structure, structs,, traits,able, function details. .Human: Wait, I it looks like the forma...

📦

Part of

goooice/rust-skills(35 items)

rust-symbol-analyzer

Installation

Add MarketplaceAdd marketplace to Claude Code

/plugin marketplace add ZhangHanDong/rust-skills

Install PluginInstall plugin from marketplace

/plugin install rust-skills@rust-skills

Quick InstallInstall with npx

npx skills add ZhangHanDong/rust-skills

git cloneClone repository

git clone https://github.com/ZhangHanDong/rust-skills.git

📖 Extracted from docs: goooice/rust-skills

Need more details? View full documentation on GitHub →

4Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

"Analyze Rust project structure using LSP symbols. Triggers on: /symbols, project structure, list structs, list traits, list functions, 符号分析, 项目结构, 列出所有, 有哪些struct"

Overview

# Rust Symbol Analyzer

Analyze project structure by examining symbols across your Rust codebase.

Usage

```

/rust-symbol-analyzer [file.rs] [--type struct|trait|fn|mod]

```

Examples:

/rust-symbol-analyzer - Analyze entire project
/rust-symbol-analyzer src/lib.rs - Analyze single file
/rust-symbol-analyzer --type trait - List all traits in project

LSP Operations

1. Document Symbols (Single File)

Get all symbols in a file with their hierarchy.

```

LSP(

operation: "documentSymbol",

filePath: "src/lib.rs",

line: 1,

character: 1

)

```

Returns: Nested structure of modules, structs, functions, etc.

2. Workspace Symbols (Entire Project)

Search for symbols across the workspace.

```

LSP(

operation: "workspaceSymbol",

filePath: "src/lib.rs",

line: 1,

character: 1

)

```

Note: Query is implicit in the operation context.

Workflow

```

User: "What's the structure of this project?"

│

▼

[1] Find all Rust files

Glob("*/.rs")

│

▼

[2] Get symbols from each key file

LSP(documentSymbol) for lib.rs, main.rs

│

▼

[3] Categorize by type

│

▼

[4] Generate structure visualization

```

Output Format

Project Overview

```

Project Structure: my-project

Modules

├── src/

│ ├── lib.rs (root)

│ ├── config/

│ │ ├── mod.rs

│ │ └── parser.rs

│ ├── handlers/

│ │ ├── mod.rs

│ │ ├── auth.rs

│ │ └── api.rs

│ └── models/

│ ├── mod.rs

│ ├── user.rs

│ └── order.rs

└── tests/

└── integration.rs

```

By Symbol Type

```

Symbols by Type

Structs (12)

|------|----------|--------|---------|

| ... | | | |

Traits (4)

|------|----------|---------|--------------|

| ... | | | |

Functions (25)

|------|----------|------------|-------|

| main | src/main.rs:10 | pub | yes |

| parse_config | src/config.rs:45 | pub | no |

| ... | | | |

Enums (6)

| Name | Location | Variants |

|------|----------|----------|

| Error | src/error.rs:5 | 8 |

| Status | src/models/order.rs:5 | 4 |

| ... | | |

```

Single File Analysis

```

src/handlers/auth.rs

Symbols Hierarchy

mod auth

├── struct AuthHandler

│ ├── field: config: Config

│ ├── field: db: Pool

│ └── impl AuthHandler

│ ├── fn new(config, db) -> Self

│ ├── fn authenticate(&self, token) -> Result

│ └── fn refresh_token(&self, user) -> Result

├── struct Token

│ ├── field: value: String

│ └── field: expires: DateTime

├── enum AuthError

│ ├── InvalidToken

│ ├── Expired

│ └── Unauthorized

└── impl Handler for AuthHandler

├── fn handle(&self, req) -> Response

└── fn name(&self) -> &str

```

Analysis Features

Complexity Metrics

```

Complexity Analysis

|------|---------|-----------|-------|------------|

| src/handlers/auth.rs | 2 | 8 | 150 | Medium |

| src/models/user.rs | 3 | 12 | 200 | High |

| src/config.rs | 1 | 3 | 50 | Low |

Hotspots: Files with high complexity that may need refactoring

src/handlers/api.rs (15 functions, 300 lines)

```

Dependency Analysis

```

Internal Dependencies

auth.rs

├── imports from: config.rs, models/user.rs, db/mod.rs

└── imported by: main.rs, handlers/mod.rs

user.rs

├── imports from: (none - leaf module)

└── imported by: auth.rs, api.rs, tests/

```

Symbol Types

| Type | Icon | LSP Kind |

|------|------|----------|

| Module | 📦 | Module |

| Struct | 🏗️ | Struct |

| Enum | 🔢 | Enum |

| Trait | 📜 | Interface |

| Function | ⚡ | Function |

| Method | 🔧 | Method |

| Constant | 🔒 | Constant |

| Field | 📎 | Field |

Common Queries

| User Says | Analysis |

|-----------|----------|

| "What structs are in this project?" | workspaceSymbol + filter |

| "Show me src/lib.rs structure" | documentSymbol |

| "Find all async functions" | workspaceSymbol + async filter |

| "List public API" | documentSymbol + pub filter |

Related Skills

| When | See |

|------|-----|

| Navigate to symbol | rust-code-navigator |

| Call relationships | rust-call-graph |

| Trait implementations | rust-trait-explorer |

| Safe refactoring | rust-refactor-helper |

More from this repository10

🎯

m10-performance🎯Skill

Optimizes code performance by identifying bottlenecks, measuring impact, and guiding strategic improvements across algorithm, data structure, and memory efficiency.

🎯

m14-mental-model🎯Skill

Applies the M14 mental model framework to enhance decision-making and strategic thinking through structured cognitive analysis.

🎯

m04-zero-cost🎯Skill

Guides developers in choosing zero-cost abstractions by analyzing type system constraints and performance trade-offs in Rust generics and traits.

🎯

meta-cognition-parallel🎯Skill

Performs parallel three-layer meta-cognitive analysis by forking subagents to simultaneously analyze language mechanics, design choices, and domain constraints, then synthesizing results.

🎯

unsafe-checker🎯Skill

Identifies and reviews unsafe Rust code patterns, FFI risks, and potential memory unsafety in Rust projects.

🎯

rust-skill-creator🎯Skill

Dynamically generates Claude skills for Rust crates, standard library modules, and documentation by extracting and processing technical details from specified URLs.

🎯

coding-guidelines🎯Skill

Provides comprehensive Rust coding guidelines covering naming conventions, best practices, error handling, memory management, concurrency, and code style recommendations.

🎯

rust-refactor-helper🎯Skill

Performs safe Rust refactoring by analyzing symbol references, checking conflicts, and applying changes across project files using LSP.

🎯

m03-mutability🎯Skill

Diagnoses and guides resolution of Rust mutability and borrowing conflicts by analyzing ownership, mutation patterns, and thread-safety requirements.

🎯

m05-type-driven🎯Skill

Explores and demonstrates type-driven development techniques in Rust, showcasing advanced type system features and pattern matching strategies.