JetBrains RustRover 2026.1 Adds Rust-Aware Call Hierarchy for Large Codebases

JetBrains shipped RustRover 2026.1 on March 30, and the headline feature is something Rust developers working in large codebases have needed for a while: a Call Hierarchy view that actually understands Rust's type system.

The distinction matters. A naive call hierarchy in any IDE can follow function calls as text references. What RustRover's new implementation does differently is resolve trait-object indirection and distinguish between trait method dispatch and calls to concrete implementations. When you invoke the Call Hierarchy on a function buried three abstraction layers deep, you see the real call tree, not a wall of dyn Trait noise that leaves you guessing which concrete type is executing at runtime. JetBrains put it plainly in the release notes: "RustRover 2026.1 adds Call Hierarchy support for Rust, so you can explore call relationships in a dedicated view and navigate complicated code faster."

The dedicated tool window surfaces both callers and callees for any selected function or method, giving you bidirectional visibility without reaching for grep or ripgrep on the side.

The timing reflects where the Rust ecosystem actually sits right now. Multi-crate monorepos, async-heavy services, and trait-heavy abstraction patterns have become standard in production Rust. Jump-to-definition and symbol search, the tools most editors have provided for years, start breaking down when you need to trace an ownership bug or profile a hot path across a half-dozen crates. Call hierarchy tooling at the semantic level is where an IDE needs to be in 2026 to stay useful on real Rust projects.

The 2026.1 release also bundles performance and navigation improvements aimed at large codebases, alongside usability refinements across traits and generics. JetBrains framed the entire release as tailored to Rust's semantics rather than a port of features from their Java or Kotlin tooling, which is the right approach. Rust's ownership model and the relationship between trait definitions and concrete implementations don't map cleanly onto object-oriented dispatch, and tooling that conflates them has always produced misleading results.

For engineering teams weighing Rust adoption against developer velocity concerns, releases like this chip away at the most credible objection on the table: that Rust's tooling still lags behind Java or C# in IDE sophistication. With trait-aware call resolution now shipping in RustRover, that argument gets harder to make.