Features

Annotations

Source: annotations.rs

Provides user with annotations above items for looking up references or impl blocks and running/debugging binaries.

Auto Import

Source: auto_import.rs

Using the auto-import assist it is possible to insert missing imports for unresolved items. When inserting an import it will do so in a structured manner by keeping imports grouped, separated by a newline in the following order:

• std and core
• External Crates
• Current Crate, paths prefixed by crate
• Current Module, paths prefixed by self
• Super Module, paths prefixed by super

Example:

use std::fs::File;

use itertools::Itertools;
use syntax::ast;

use crate::utils::insert_use;

use self::auto_import;

use super::AssistContext;

Import Granularity

It is possible to configure how use-trees are merged with the imports.granularity.group setting. It has the following configurations:

• crate: Merge imports from the same crate into a single use statement. This kind of nesting is only supported in Rust versions later than 1.24.
• module: Merge imports from the same module into a single use statement.
• item: Don't merge imports at all, creating one import per item.
• preserve: Do not change the granularity of any imports. For auto-import this has the same effect as item.
• one: Merge all imports into a single use statement as long as they have the same visibility and attributes.

In VS Code the configuration for this is rust-analyzer.imports.granularity.group.

Import Prefix

The style of imports in the same crate is configurable through the imports.prefix setting. It has the following configurations:

• crate: This setting will force paths to be always absolute, starting with the crate prefix, unless the item is defined outside of the current crate.
• self: This setting will force paths that are relative to the current module to always start with self. This will result in paths that always start with either crate, self, super or an extern crate identifier.
• plain: This setting does not impose any restrictions in imports.

In VS Code the configuration for this is rust-analyzer.imports.prefix.

Completion With Autoimport

Source: flyimport.rs

When completing names in the current scope, proposes additional imports from other modules or crates, if they can be qualified in the scope, and their name contains all symbols from the completion input.

To be considered applicable, the name must contain all input symbols in the given order, not necessarily adjacent. If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the containing is checked case-insensitively.

fn main() {
    pda$0
}
# pub mod std { pub mod marker { pub struct PhantomData { } } }

->

use std::marker::PhantomData;

fn main() {
    PhantomData
}
# pub mod std { pub mod marker { pub struct PhantomData { } } }

Also completes associated items, that require trait imports. If any unresolved and/or partially-qualified path precedes the input, it will be taken into account. Currently, only the imports with their import path ending with the whole qualifier will be proposed (no fuzzy matching for qualifier).

mod foo {
    pub mod bar {
        pub struct Item;

        impl Item {
            pub const TEST_ASSOC: usize = 3;
        }
    }
}

fn main() {
    bar::Item::TEST_A$0
}

->

use foo::bar;

mod foo {
    pub mod bar {
        pub struct Item;

        impl Item {
            pub const TEST_ASSOC: usize = 3;
        }
    }
}

fn main() {
    bar::Item::TEST_ASSOC
}

NOTE: currently, if an assoc item comes from a trait that's not currently imported, and it also has an unresolved and/or partially-qualified path, no imports will be proposed.

Fuzzy search details

To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only (i.e. in HashMap in the std::collections::HashMap path). For the same reasons, avoids searching for any path imports for inputs with their length less than 2 symbols (but shows all associated items for any input length).

Import configuration

It is possible to configure how use-trees are merged with the imports.granularity.group setting. Mimics the corresponding behavior of the Auto Import feature.

LSP and performance implications

The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the additionalTextEdits (case-sensitive) resolve client capability in its client capabilities. This way the server is able to defer the costly computations, doing them for a selected completion item only. For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones, which might be slow ergo the feature is automatically disabled.

Feature toggle

The feature can be forcefully turned off in the settings with the rust-analyzer.completion.autoimport.enable flag. Note that having this flag set to true does not guarantee that the feature is enabled: your client needs to have the corresponding capability enabled.

Debug ItemTree

Source: view_item_tree.rs

Displays the ItemTree of the currently open file, for debugging.

Expand Macro Recursively

Source: expand_macro.rs

Shows the full macro expansion of the macro at the current caret position.

Expand and Shrink Selection

Source: extend_selection.rs

Extends or shrinks the current selection to the encompassing syntactic construct (expression, statement, item, module, etc). It works with multiple cursors.

File Structure

Source: file_structure.rs

Provides a tree of the symbols defined in the file. Can be used to

• fuzzy search symbol in a file (super useful)
• draw breadcrumbs to describe the context around the cursor
• draw outline of the file

Find All References

Source: references.rs

Shows all references of the item at the cursor location

Folding

Source: folding_ranges.rs

Defines folding regions for curly braced blocks, runs of consecutive use, mod, const or static items, and region / endregion comment markers.

Format String Completion

Source: format_like.rs

"Result {result} is {2 + 2}" is expanded to the "Result {} is {}", result, 2 + 2.

The following postfix snippets are available:

• format -> format!(...)
• panic -> panic!(...)
• println -> println!(...)
• log: ** logd -> log::debug!(...) ** logt -> log::trace!(...) ** logi -> log::info!(...) ** logw -> log::warn!(...) ** loge -> log::error!(...)

Go to Declaration

Source: goto_declaration.rs

Navigates to the declaration of an identifier.

This is the same as Go to Definition with the following exceptions:

• outline modules will navigate to the mod name; item declaration
• trait assoc items will navigate to the assoc item of the trait declaration as opposed to the trait impl
• fields in patterns will navigate to the field declaration of the struct, union or variant

Go to Definition

Source: goto_definition.rs

Navigates to the definition of an identifier.

For outline modules, this will navigate to the source file of the module.

Go to Implementation

Source: goto_implementation.rs

Navigates to the impl items of types.

Go to Type Definition

Source: goto_type_definition.rs

Navigates to the type of an identifier.

Highlight Related

Source: highlight_related.rs

Highlights constructs related to the thing under the cursor:

1. if on an identifier, highlights all references to that identifier in the current file
   • additionally, if the identifier is a trait in a where clause, type parameter trait bound or use item, highlights all references to that trait's assoc items in the corresponding scope
2. if on an async or await token, highlights all yield points for that async context
3. if on a return or fn keyword, ? character or -> return type arrow, highlights all exit points for that context
4. if on a break, loop, while or for token, highlights all break points for that loop or block context
5. if on a move or | token that belongs to a closure, highlights all captures of the closure.

Note: ?, | and -> do not currently trigger this behavior in the VSCode editor.

Hover

Source: hover.rs

Shows additional information, like the type of an expression or the documentation for a definition when "focusing" code. Focusing is usually hovering with a mouse, but can also be triggered with a shortcut.

Inlay Hints

Source: inlay_hints.rs

rust-analyzer shows additional information inline with the source code. Editors usually render this using read-only virtual text snippets interspersed with code.

rust-analyzer by default shows hints for

• types of local variables
• names of function arguments
• names of const generic parameters
• types of chained expressions

Optionally, one can enable additional hints for

• return types of closure expressions
• elided lifetimes
• compiler inserted reborrows
• names of generic type and lifetime parameters

Note: inlay hints for function argument names are heuristically omitted to reduce noise and will not appear if any of the following criteria are met:

• the parameter name is a suffix of the function's name
• the argument is a qualified constructing or call expression where the qualifier is an ADT
• exact argument<->parameter match(ignoring leading underscore) or parameter is a prefix/suffix of argument with _ splitting it off
• the parameter name starts with ra_fixture
• the parameter name is a well known name in a unary function
• the parameter name is a single character in a unary function

Interpret A Function, Static Or Const.

Source: interpret.rs

Join Lines

Source: join_lines.rs

Join selected lines into one, smartly fixing up whitespace, trailing commas, and braces.

See this gif for the cases handled specially by joined lines.

Magic Completions

Source: lib.rs

In addition to usual reference completion, rust-analyzer provides some ✨magic✨ completions as well:

Keywords like if, else while, loop are completed with braces, and cursor is placed at the appropriate position. Even though if is easy to type, you still want to complete it, to get { } for free! return is inserted with a space or ; depending on the return type of the function.

When completing a function call, () are automatically inserted. If a function takes arguments, the cursor is positioned inside the parenthesis.

There are postfix completions, which can be triggered by typing something like foo().if. The word after . determines postfix completion. Possible variants are:

• expr.if -> if expr {} or if let ... {} for Option or Result
• expr.match -> match expr {}
• expr.while -> while expr {} or while let ... {} for Option or Result
• expr.ref -> &expr
• expr.refm -> &mut expr
• expr.let -> let $0 = expr;
• expr.lete -> let $1 = expr else { $0 };
• expr.letm -> let mut $0 = expr;
• expr.not -> !expr
• expr.dbg -> dbg!(expr)
• expr.dbgr -> dbg!(&expr)
• expr.call -> (expr)

There also snippet completions:

Expressions

• pd -> eprintln!(" = {:?}", );
• ppd -> eprintln!(" = {:#?}", );

Items

• tfn -> #[test] fn feature(){}
• tmod ->

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_name() {}
}

And the auto import completions, enabled with the rust-analyzer.completion.autoimport.enable setting and the corresponding LSP client capabilities. Those are the additional completion options with automatic use import and options from all project importable items, fuzzy matched against the completion input.

Matching Brace

Source: matching_brace.rs

If the cursor is on any brace (<>(){}[]||) which is a part of a brace-pair, moves cursor to the matching brace. It uses the actual parser to determine braces, so it won't confuse generics with comparisons.

Memory Usage

Source: apply_change.rs

Clears rust-analyzer's internal database and prints memory usage statistics.

Move Item

Source: move_item.rs

Move item under cursor or selection up and down.

On Enter

Source: on_enter.rs

rust-analyzer can override Enter key to make it smarter:

• Enter inside triple-slash comments automatically inserts ///
• Enter in the middle or after a trailing space in // inserts //
• Enter inside //! doc comments automatically inserts //!
• Enter after { indents contents and closing } of single-line block

This action needs to be assigned to shortcut explicitly.

Note that, depending on the other installed extensions, this feature can visibly slow down typing. Similarly, if rust-analyzer crashes or stops responding, Enter might not work. In that case, you can still press Shift-Enter to insert a newline.

VS Code

Add the following to keybindings.json:

{
  "key": "Enter",
  "command": "rust-analyzer.onEnter",
  "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust"
}

When using the Vim plugin:

{
  "key": "Enter",
  "command": "rust-analyzer.onEnter",
  "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust && vim.mode == 'Insert'"
}

On Typing Assists

Source: typing.rs

Some features trigger on typing certain characters:

• typing let = tries to smartly add ; if = is followed by an existing expression
• typing = between two expressions adds ; when in statement position
• typing = to turn an assignment into an equality comparison removes ; when in expression position
• typing . in a chain method call auto-indents
• typing { or ( in front of an expression inserts a closing } or ) after the expression
• typing { in a use item adds a closing } in the right place
• typing > to complete a return type -> will insert a whitespace after it

VS Code

Add the following to settings.json:

"editor.formatOnType": true,

Open Docs

Source: doc_links.rs

Retrieve a links to documentation for the given symbol.

The simplest way to use this feature is via the context menu. Right-click on the selected item. The context menu opens. Select Open Docs.

Parent Module

Source: parent_module.rs

Navigates to the parent module of the current module.

Related Tests

Source: runnables.rs

Provides a sneak peek of all tests where the current item is used.

The simplest way to use this feature is via the context menu. Right-click on the selected item. The context menu opens. Select Peek Related Tests.

Rename

Source: rename.rs

Renames the item below the cursor and all of its references

Run

Source: runnables.rs

Shows a popup suggesting to run a test/benchmark/binary at the current cursor location. Super useful for repeatedly running just a single test. Do bind this to a shortcut!

Semantic Syntax Highlighting

Source: syntax_highlighting.rs

rust-analyzer highlights the code semantically. For example, Bar in foo::Bar might be colored differently depending on whether Bar is an enum or a trait. rust-analyzer does not specify colors directly, instead it assigns a tag (like struct) and a set of modifiers (like declaration) to each token. It's up to the client to map those to specific colors.

The general rule is that a reference to an entity gets colored the same way as the entity itself. We also give special modifier for mut and &mut local variables.

Token Tags

Rust-analyzer currently emits the following token tags:

• For items:

• For literals:

• For operators:

• For punctuation:

Token Modifiers

Token modifiers allow to style some elements in the source code more precisely.

Rust-analyzer currently emits the following token modifiers:

Show Dependency Tree

Source: fetch_crates.rs

Shows a view tree with all the dependencies of this project

Show Syntax Tree

Source: view_syntax_tree.rs

Shows a tree view with the syntax tree of the current file

Status

Source: status.rs

Shows internal statistic about memory usage of rust-analyzer.

Structural Search and Replace

Source: lib.rs

Search and replace with named wildcards that will match any expression, type, path, pattern or item. The syntax for a structural search replace command is <search_pattern> ==>> <replace_pattern>. A $<name> placeholder in the search pattern will match any AST node and $<name> will reference it in the replacement. Within a macro call, a placeholder will match up until whatever token follows the placeholder.

All paths in both the search pattern and the replacement template must resolve in the context in which this command is invoked. Paths in the search pattern will then match the code if they resolve to the same item, even if they're written differently. For example if we invoke the command in the module foo with a pattern of Bar, then code in the parent module that refers to foo::Bar will match.

Paths in the replacement template will be rendered appropriately for the context in which the replacement occurs. For example if our replacement template is foo::Bar and we match some code in the foo module, we'll insert just Bar.

Inherent method calls should generally be written in UFCS form. e.g. foo::Bar::baz($s, $a) will match $s.baz($a), provided the method call baz resolves to the method foo::Bar::baz. When a placeholder is the receiver of a method call in the search pattern (e.g. $s.foo()), but not in the replacement template (e.g. bar($s)), then *, & and &mut will be added as needed to mirror whatever autoderef and autoref was happening implicitly in the matched code.

The scope of the search / replace will be restricted to the current selection if any, otherwise it will apply to the whole workspace.

Placeholders may be given constraints by writing them as ${<name>:<constraint1>:<constraint2>...}.

Supported constraints:

Available via the command rust-analyzer.ssr.

// Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]

// BEFORE
String::from(foo(y + 5, z))

// AFTER
String::from((y + 5).foo(z))

Also available as an assist, by writing a comment containing the structural search and replace rule. You will only see the assist if the comment can be parsed as a valid structural search and replace rule.

// Place the cursor on the line below to see the assist 💡.
// foo($a, $b) ==>> ($a).foo($b)

User Snippet Completions

Source: snippet.rs

rust-analyzer allows the user to define custom (postfix)-snippets that may depend on items to be accessible for the current scope to be applicable.

A custom snippet can be defined by adding it to the rust-analyzer.completion.snippets.custom object respectively.

{
  "rust-analyzer.completion.snippets.custom": {
    "thread spawn": {
      "prefix": ["spawn", "tspawn"],
      "body": [
        "thread::spawn(move || {",
        "\t$0",
        "});",
      ],
      "description": "Insert a thread::spawn call",
      "requires": "std::thread",
      "scope": "expr",
    }
  }
}

In the example above:

• "thread spawn" is the name of the snippet.

• prefix defines one or more trigger words that will trigger the snippets completion. Using postfix will instead create a postfix snippet.

• body is one or more lines of content joined via newlines for the final output.

• description is an optional description of the snippet, if unset the snippet name will be used.

• requires is an optional list of item paths that have to be resolvable in the current crate where the completion is rendered.

View Crate Graph

Source: view_crate_graph.rs

Renders the currently loaded crate graph as an SVG graphic. Requires the dot tool, which is part of graphviz, to be installed.

Only workspace crates are included, no crates.io dependencies or sysroot crates.

View Hir

Source: view_hir.rs

View Memory Layout

Source: view_memory_layout.rs

Displays the recursive memory layout of a datatype.

View Mir

Source: view_mir.rs

Workspace Symbol

Source: symbol_index.rs

Uses fuzzy-search to find types, modules and functions by name across your project and dependencies. This is the most useful feature, which improves code navigation tremendously. It mostly works on top of the built-in LSP functionality, however # and * symbols can be used to narrow down the search. Specifically,

• Foo searches for Foo type in the current workspace
• foo# searches for foo function in the current workspace
• Foo* searches for Foo type among dependencies, including stdlib
• foo#* searches for foo function among dependencies

That is, # switches from "types" to all symbols, * switches from the current workspace to dependencies.

Note that filtering does not currently work in VSCode due to the editor never sending the special symbols to the language server. Instead, you can configure the filtering via the rust-analyzer.workspace.symbol.search.scope and rust-analyzer.workspace.symbol.search.kind settings. Symbols prefixed with __ are hidden from the search results unless configured otherwise.