rust-analyzer

Provides context-aware code completion by parsing the current file's AST and analyzing scope, type information, and available symbols in the workspace. When a completion is selected, rust-analyzer automatically inserts necessary use statements and qualified paths, eliminating manual import management. Uses incremental parsing to maintain accuracy as code is edited.

Enables navigation to symbol definitions by analyzing the AST and maintaining a symbol index across the entire workspace. Supports go-to-definition, go-to-implementation, go-to-type-definition, and find-all-references by resolving type information and tracking symbol usage. Works across file boundaries and into dependency crates via Cargo metadata.

Provides automated refactoring to extract a selected code block into a new variable or function. Analyzes the selected code to determine required parameters, return types, and variable captures. Automatically inserts the new function/variable and updates the original code to use it.

Enables navigation into source code of Rust dependencies by resolving crate paths through Cargo.lock and source downloads. Allows developers to jump to definitions in external crates, view their source code, and understand how they work. Integrates with cargo to fetch source code for dependencies.

Discovers Rust tests (functions marked with #[test] or in test modules) and provides UI elements (CodeLens) to run individual tests or test suites directly from the editor. Integrates with cargo test to execute tests and display results inline.

Integrates with rustfmt (Rust's standard code formatter) to automatically format code on save or on demand. Applies rustfmt's formatting rules to ensure consistent code style across the project. Respects rustfmt.toml configuration files.

Performs incremental type inference on the current file and displays inferred types via hover tooltips. Leverages Rust's type system to compute types for expressions, function parameters, and return values without requiring explicit annotations. Integrates with Cargo documentation to display crate and item-level docs inline.

Continuously analyzes code as it is typed and reports compilation errors, warnings, and lints as inline squiggles. Provides quick-fix suggestions (code actions) accessible via the lightbulb menu that can automatically apply transformations such as adding missing imports, fixing type mismatches, or applying clippy suggestions. Uses the Rust compiler's error messages and rustc's suggestion system.

Applies token-level semantic highlighting based on AST analysis and type information, rather than regex-based syntax highlighting. Classifies tokens as variables, functions, types, keywords, etc., and applies VSCode theme colors accordingly. Updates incrementally as code is edited to maintain accuracy.

Indexes all symbols (functions, types, constants, modules) in the workspace and provides fuzzy-searchable symbol navigation via the VSCode command palette (Ctrl+T). Allows developers to jump to any symbol by name without knowing its file location. Supports filtering by symbol kind (function, type, etc.).

Enables renaming of symbols (functions, types, variables, modules) with automatic updates to all references across the workspace. Respects Rust's scoping rules to avoid renaming unrelated symbols with the same name in different scopes. Uses the symbol index and type information to identify all occurrences.

Displays inline type annotations and parameter names as non-editable hints in the editor. Shows inferred types for variables without explicit annotations, parameter names at function call sites, and lifetime annotations. Helps developers understand code without hovering or navigating to definitions.

Provides call hierarchy views showing which functions call a given function and which functions it calls. Enables exploration of function call chains and implementation hierarchies for traits. Accessible via right-click context menu or command palette.

Provides the ability to expand macros and view the generated code they produce. Helps developers understand macro behavior by showing the expanded form. Supports both declarative macros (macro_rules!) and procedural macros (with limitations). Accessible via code action or hover.