🎯

rust-call-graph

🎯Skill

from actionbook/rust-skills

What it does

Generates and visualizes Rust function call graphs using LSP, revealing function relationships and call hierarchies.

📦

Part of

actionbook/rust-skills(35 items)

rust-call-graph

Installation

Quick InstallInstall with npx

npx skills add ZhangHanDong/rust-skills

CargoRun with Cargo (Rust)

cargo install cowork

git cloneClone repository

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

Add MarketplaceAdd marketplace to Claude Code

/plugin marketplace add ZhangHanDong/rust-skills

📖 Extracted from docs: actionbook/rust-skills

Need more details? View full documentation on GitHub →

15Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

"Visualize Rust function call graphs using LSP. Triggers on: /call-graph, call hierarchy, who calls, what calls, 调用图, 调用关系, 谁调用了, 调用了谁"

Overview

# Rust Call Graph

Visualize function call relationships using LSP call hierarchy.

Usage

```

/rust-call-graph [--depth N] [--direction in|out|both]

```

Options:

--depth N: How many levels to traverse (default: 3)
--direction: in (callers), out (callees), both

Examples:

/rust-call-graph process_request - Show both callers and callees
/rust-call-graph handle_error --direction in - Show only callers
/rust-call-graph main --direction out --depth 5 - Deep callee analysis

LSP Operations

1. Prepare Call Hierarchy

Get the call hierarchy item for a function.

```

LSP(

operation: "prepareCallHierarchy",

filePath: "src/handler.rs",

line: 45,

character: 8

)

```

2. Incoming Calls (Who calls this?)

```

LSP(

operation: "incomingCalls",

filePath: "src/handler.rs",

line: 45,

character: 8

)

```

3. Outgoing Calls (What does this call?)

```

LSP(

operation: "outgoingCalls",

filePath: "src/handler.rs",

line: 45,

character: 8

)

```

Workflow

```

User: "Show call graph for process_request"

│

▼

[1] Find function location

LSP(workspaceSymbol) or Grep

│

▼

[2] Prepare call hierarchy

LSP(prepareCallHierarchy)

│

▼

[3] Get incoming calls (callers)

LSP(incomingCalls)

│

▼

[4] Get outgoing calls (callees)

LSP(outgoingCalls)

│

▼

[5] Recursively expand to depth N

│

▼

[6] Generate ASCII visualization

```

Output Format

Incoming Calls (Who calls this?)

```

Callers of `process_request`

main

└── run_server

└── handle_connection

└── process_request ◄── YOU ARE HERE

```

Outgoing Calls (What does this call?)

```

Callees of `process_request`

process_request ◄── YOU ARE HERE

├── parse_headers

│ └── validate_header

├── authenticate

│ ├── check_token

│ └── load_user

├── execute_handler

│ └── [dynamic dispatch]

└── send_response

└── serialize_body

```

Bidirectional (Both)

```

Call Graph for `process_request`

┌─────────────────┐

│ main │

└────────┬────────┘

│

┌────────▼────────┐

│ run_server │

└────────┬────────┘

│

┌────────▼────────┐

│handle_connection│

└────────┬────────┘

│

┌────────────────────┼────────────────────┐

│ │ │

┌───────▼───────┐ ┌───────▼───────┐ ┌───────▼───────┐

│ parse_headers │ │ authenticate │ │send_response │

└───────────────┘ └───────┬───────┘ └───────────────┘

│

┌───────┴───────┐

│ │

┌──────▼──────┐ ┌──────▼──────┐

│ check_token │ │ load_user │

└─────────────┘ └─────────────┘

```

Analysis Insights

After generating the call graph, provide insights:

```

Analysis

Entry Points: main, test_process_request

Leaf Functions: validate_header, serialize_body

Hot Path: main → run_server → handle_connection → process_request

Complexity: 12 functions, 3 levels deep

Potential Issues:

authenticate has high fan-out (4 callees)
process_request is called from 3 places (consider if this is intentional)

```

Common Patterns

| User Says | Direction | Use Case |

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

| "Who calls X?" | incoming | Impact analysis |

| "What does X call?" | outgoing | Understanding implementation |

| "Show call graph" | both | Full picture |

| "Trace from main to X" | outgoing | Execution path |

Visualization Options

| Style | Best For |

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

| Tree (default) | Simple hierarchies |

| Box diagram | Complex relationships |

| Flat list | Many connections |

| Mermaid | Export to docs |

Mermaid Export

```mermaid

graph TD

main --> run_server

run_server --> handle_connection

handle_connection --> process_request

process_request --> parse_headers

process_request --> authenticate

process_request --> send_response

```

Related Skills

| When | See |

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

| Find definition | rust-code-navigator |

| Project structure | rust-symbol-analyzer |

| Trait implementations | rust-trait-explorer |

| Safe refactoring | rust-refactor-helper |

More from this repository10

🏪

actionbook-rust-skills🏪Marketplace

Comprehensive Rust development assistant with meta-question routing, coding guidelines, version queries, and ecosystem support

🎯

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, dependencies, and potential impacts using Language Server Protocol (LSP) operations.

🎯

m09-domain🎯Skill

Guides domain modeling in Rust by helping identify entities, value objects, aggregates, and their ownership patterns with domain-driven design principles.

🎯

m05-type-driven🎯Skill

Enforces compile-time type safety by preventing invalid states through type-level design techniques like newtypes, type states, and phantom types.

🎯

rust-learner🎯Skill

Retrieves and provides comprehensive Rust and crate information, including versions, features, documentation, and changelogs from authoritative sources.

🎯

m02-resource🎯Skill

Guides developers in selecting the right smart pointer and resource management strategy based on ownership, thread safety, and design constraints.

🎯

rust-trait-explorer🎯Skill

Explores Rust trait implementations, revealing which types implement specific traits and their implementation details using LSP.

🎯

m07-concurrency🎯Skill

Diagnoses and resolves Rust concurrency challenges by tracing thread safety, ownership, and async/sync design constraints across different computational domains.

🎯

m12-lifecycle🎯Skill

Guides resource lifecycle design by analyzing creation, usage, cleanup strategies, and ownership patterns for efficient and safe resource management in Rust.