rust-call-graph

Generate ASCII and Mermaid visualizations of Rust function call graphs via LSP.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/VoldemortGin/claude-skills --skill rust-call-graph-voldemortgin
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: rust-call-graph
Source: https://github.com/VoldemortGin/claude-skills/tree/main/skills/rust-call-graph
Command: npx skills add https://github.com/VoldemortGin/claude-skills --skill rust-call-graph-voldemortgin

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps developers understand the complex relationships between functions in Rust code, making it easier to debug, refactor, and comprehend codebases.

Core Features & Use Cases

  • Visualize Call Hierarchies: Generate visual representations of which functions call others and which functions are called by a given function.
  • Analyze Function Relationships: Understand the flow of execution and identify dependencies between different parts of the code.
  • Use Case: When debugging a performance issue, you can use this skill to see all the functions that lead up to a slow function and all the functions that the slow function calls, helping to pinpoint the bottleneck.

Quick Start

Show the call graph for the 'process_request' function in 'src/handler.rs'.

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 function call graph to understand code flow?▼

You can visualize a Rust function call graph by generating ASCII and Mermaid representations using Language Server Protocol (LSP) call hierarchy information. This helps developers comprehend execution flow and identify dependencies between functions.

Can I trace both incoming callers and outgoing callees for a specific Rust function?▼

Yes, you can trace incoming callers, outgoing callees, or both simultaneously for a specific Rust function. The analysis supports configurable depth for recursive exploration to map the complete call hierarchy.

What is the best way to debug a performance bottleneck using a Rust call graph visualization?▼

Using a Rust call graph visualization helps debug performance issues by showing all functions leading to and called by a slow function. This visual mapping pinpoints execution bottlenecks and impact areas within complex codebases.

Does this Rust call graph analysis require Language Server Protocol support?▼

Yes, the call graph analysis relies on Language Server Protocol (LSP) call hierarchy information to function. It extracts incoming and outgoing call relationships directly through LSP to build accurate visualizations.

How do I analyze the impact of refactoring a function across a complex Rust codebase?▼

You can analyze refactoring impact by generating a call graph that traces all incoming callers of a target Rust function. This visualizes dependent functions across the codebase, ensuring safe modifications without breaking execution flow.

What are the limitations of using Mermaid and ASCII for Rust call graph visualizations?▼

Mermaid and ASCII visualizations may become difficult to read when analyzing deeply nested Rust call hierarchies with high recursive depth. Large function graphs can exceed terminal display limits or Mermaid rendering constraints.