rust-call-graph_skill

Overview

This skill visualizes Rust function call graphs using the language server call hierarchy. It generates caller, callee, or bidirectional graphs and produces readable ASCII or mermaid outputs to support impact analysis and code exploration. Use it to trace execution paths, find hot paths, and surface high fan-out or frequently-called functions.

How this skill works

The skill locates a function symbol, then calls the LSP prepareCallHierarchy to get the base item. It expands incomingCalls and outgoingCalls via LSP, recursively up to a configured depth, and aggregates results. Finally it renders an ASCII tree, optional box diagram, or Mermaid graph and computes simple analysis like entry points, leaf functions, and hot paths.

When to use it

• Perform impact analysis before changing a function (who calls this?).
• Understand what a function invokes to inspect dependencies and side effects.
• Trace execution paths from main or tests into a target function.
• Document call relationships for code reviews or architecture notes.
• Identify hot paths, high fan-out functions, or potential refactor targets.

Best practices

• Start with depth 2–3 to get a manageable overview, increase for deeper investigation.
• Prefer bidirectional view when you need full context; use incoming or outgoing for focused queries.
• Combine LSP results with grep or workspace symbols if the server misses a location.
• Annotate dynamic dispatch or external crate calls explicitly in the output.
• Export complex graphs to Mermaid for inclusion in docs or deeper visualization tools.

Example use cases

• Show callers and callees for process_request to reveal hot paths and dependencies.
• Run incoming-only analysis on handle_error to see all impact sites before a change.
• Trace from main out to a module with --depth 5 to map a long execution chain.
• Export a service handler graph to Mermaid for architecture documentation.
• Detect functions with unusually high fan-out (many callees) for targeted refactoring.