Rust调用关系图生成器 - 可视化函数调用层次结构，提升代码分析效率

rust-call-graph by zhanghandong/rust-skills

536 周安装量

920 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/zhanghandong/rust-skills --skill rust-call-graph

开发代码规范 Rust

🇨🇳中文介绍

Rust 调用关系图

使用 LSP 调用层次结构可视化函数调用关系。

使用方法

/rust-call-graph <函数名> [--depth N] [--direction in|out|both]

选项：

--depth N: 遍历的层级数（默认：3）
--direction: in（调用者），out（被调用者），both（双向）

示例：

/rust-call-graph process_request - 显示调用者和被调用者
/rust-call-graph handle_error --direction in - 仅显示调用者

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

1. 准备调用层次结构

获取函数的调用层次结构项。

LSP(
  operation: "prepareCallHierarchy",
  filePath: "src/handler.rs",
  line: 45,
  character: 8
)

2. 传入调用（谁调用了这个函数？）

LSP(
  operation: "incomingCalls",
  filePath: "src/handler.rs",
  line: 45,
  character: 8
)

3. 传出调用（这个函数调用了什么？）

LSP(
  operation: "outgoingCalls",
  filePath: "src/handler.rs",
  line: 45,
  character: 8
)

User: "Show call graph for process_request"
    │
    ▼
[1] 查找函数位置
    LSP(workspaceSymbol) 或 Grep
    │
    ▼
[2] 准备调用层次结构
    LSP(prepareCallHierarchy)
    │
    ▼
[3] 获取传入调用（调用者）
    LSP(incomingCalls)
    │
    ▼
[4] 获取传出调用（被调用者）
    LSP(outgoingCalls)
    │
    ▼
[5] 递归扩展到深度 N
    │
    ▼
[6] 生成 ASCII 可视化图

传入调用（谁调用了这个函数？）

## `process_request` 的调用者

main
└── run_server
    └── handle_connection
        └── process_request  ◄── 当前位置

传出调用（这个函数调用了什么？）

## `process_request` 的被调用者

process_request  ◄── 当前位置
├── parse_headers
│   └── validate_header
├── authenticate
│   ├── check_token
│   └── load_user
├── execute_handler
│   └── [dynamic dispatch]
└── send_response
    └── serialize_body

## `process_request` 的调用关系图

                    ┌─────────────────┐
                    │      main       │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │   run_server    │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │handle_connection│
                    └────────┬────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
┌───────▼───────┐   ┌───────▼───────┐   ┌───────▼───────┐
│ parse_headers │   │ authenticate  │   │send_response  │
└───────────────┘   └───────┬───────┘   └───────────────┘
                            │
                    ┌───────┴───────┐
                    │               │
             ┌──────▼──────┐ ┌──────▼──────┐
             │ check_token │ │  load_user  │
             └─────────────┘ └─────────────┘

生成调用关系图后，提供洞察信息：

## 分析

**入口点：** main, test_process_request
**叶子函数：** validate_header, serialize_body
**热点路径：** main → run_server → handle_connection → process_request
**复杂度：** 12 个函数，3 层深度

**潜在问题：**
- `authenticate` 扇出度高（4 个被调用者）
- `process_request` 被 3 个地方调用（考虑这是否是有意为之）

用户表述	方向	使用场景
"谁调用了 X？"	incoming	影响分析
"X 调用了什么？"	outgoing	理解实现
"显示调用关系图"	both	完整视图
"从 main 追踪到 X"	outgoing	执行路径

样式	最佳适用场景
树状图（默认）	简单层次结构
方框图	复杂关系
扁平列表	大量连接
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

场景	查看
查找定义	rust-code-navigator
项目结构	rust-symbol-analyzer
Trait 实现	rust-trait-explorer
安全重构	rust-refactor-helper

🇺🇸English

Rust Call Graph

Visualize function call relationships using LSP call hierarchy.

Usage

/rust-call-graph <function_name> [--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

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

Weekly Installs

536

Repository

zhanghandong/rust-skills

GitHub Stars

920

First Seen

Jan 22, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode490

codex480

gemini-cli471

github-copilot462

amp421

kimi-cli418

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

103,800 周安装