rust-call-graph

Visualize Rust function call graphs using LSP call hierarchy.

3|Updated Mar 22, 2026
One-click install
npx skills add https://github.com/0xharryriddle/codex-field-kit --skill rust-call-graph-0xharryriddle
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-call-graph
Source: https://github.com/0xharryriddle/codex-field-kit/tree/main/archive/upstream/chasebuild-agent-skills/rust/skills/rust-call-graph
Command: npx skills add https://github.com/0xharryriddle/codex-field-kit --skill rust-call-graph-0xharryriddle

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Visualize Rust function call graphs using LSP call hierarchy to map interactions and help debugging and design reviews.

Core Features & Use Cases

  • LSP-driven visualization of Rust call graphs for quick comprehension.
  • Inspect incoming (callers) and outgoing (callees) relationships across modules.
  • Depth-controlled traversal and filtering to focus on relevant code paths.
  • ASCII or Mermaid-style diagrams to share findings.

Quick Start

Run the rust-call-graph tool on a target function to generate its LSP-based call graph.

Frequently Asked Questions about rust-call-graph

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I visualize a Rust call graph to trace dependencies?

Visualize a Rust call graph by using LSP call hierarchy to map incoming callers and outgoing callees. This maps function relationships across modules, helping you trace dependencies and review code design effectively.

Can I use rust-analyzer to inspect callers and callees across modules?

Yes, rust-analyzer exposes the LSP call hierarchy needed to inspect incoming callers and outgoing callees across modules. The tool uses this data to map cross-module interactions for dependency tracing and debugging.

What is the best way to generate Mermaid diagrams from Rust code?

Generate Mermaid-style diagrams from Rust code by leveraging LSP call hierarchy data. The tool maps function relationships and optionally renders them into Mermaid or ASCII diagrams to share findings.

How do I control traversal depth when analyzing a Rust call graph?

Control traversal depth by applying depth-controlled filtering to focus on relevant code paths. This narrows the LSP call hierarchy analysis to specific callers and callees, making large Rust codebases easier to explore.

Do I need an LSP-enabled environment to map Rust function interactions?

Yes, an LSP-enabled environment with rust-analyzer-compatible tooling is required. This setup exposes the incoming and outgoing call hierarchy data needed to map function interactions and generate call graphs.

Why use LSP call hierarchy for Rust debugging instead of manual tracing?

LSP call hierarchy provides depth-controlled traversal to automatically map callers and callees across modules, overcoming the limitations of manual tracing for debugging performance issues or tracing dependencies in large Rust codebases.