-//! Generated by `cargo xtask codegen feature-docs`, do not edit by hand.

-

-### Annotations

-**Source:** [annotations.rs](crates/ide/src/annotations.rs#19)

-

-Provides user with annotations above items for looking up references or impl blocks

-and running/debugging binaries.

-

-

-

-

-### Auto Import

-**Source:** [auto_import.rs](crates/ide-assists/src/handlers/auto_import.rs#15)

-

-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:

-```rust

-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](crates/ide-completion/src/completions/flyimport.rs#20)

-

-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](crates/ide/src/view_item_tree.rs#5)

-

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

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Debug ItemTree** |

-

-

-### Expand Macro Recursively

-**Source:** [expand_macro.rs](crates/ide/src/expand_macro.rs#18)

-

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

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Expand macro recursively at caret** |

-

-

-

-

-### Expand and Shrink Selection

-**Source:** [extend_selection.rs](crates/ide/src/extend_selection.rs#15)

-

-Extends or shrinks the current selection to the encompassing syntactic construct

-(expression, statement, item, module, etc). It works with multiple cursors.

-

-| Editor | Shortcut |

-|---------|----------|

-| VS Code | <kbd>Alt+Shift+→</kbd>, <kbd>Alt+Shift+←</kbd> |

-

-

-

-

-### File Structure

-**Source:** [file_structure.rs](crates/ide/src/file_structure.rs#26)

-

-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

-

-| Editor | Shortcut |

-|---------|----------|

-| VS Code | <kbd>Ctrl+Shift+O</kbd> |

-

-

-

-

-### Find All References

-**Source:** [references.rs](crates/ide/src/references.rs#42)

-

-Shows all references of the item at the cursor location

-

-| Editor | Shortcut |

-|---------|----------|

-| VS Code | <kbd>Shift+Alt+F12</kbd> |

-

-

-

-

-### Folding

-**Source:** [folding_ranges.rs](crates/ide/src/folding_ranges.rs#36)

-

-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](crates/ide-completion/src/completions/postfix/format_like.rs#0)

-

-`"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](crates/ide/src/goto_declaration.rs#13)

-

-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](crates/ide/src/goto_definition.rs#28)

-

-Navigates to the definition of an identifier.

-

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

-

-| Editor | Shortcut |

-|---------|----------|

-| VS Code | <kbd>F12</kbd> |

-

-

-

-

-### Go to Implementation

-**Source:** [goto_implementation.rs](crates/ide/src/goto_implementation.rs#11)

-

-Navigates to the impl items of types.

-

-| Editor | Shortcut |

-|---------|----------|

-| VS Code | <kbd>Ctrl+F12</kbd>

-

-

-

-

-### Go to Type Definition

-**Source:** [goto_type_definition.rs](crates/ide/src/goto_type_definition.rs#7)

-

-Navigates to the type of an identifier.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **Go to Type Definition** |

-

-

-

-

-### Highlight Related

-**Source:** [highlight_related.rs](crates/ide/src/highlight_related.rs#42)

-

-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

-1. if on an `async` or `await` token, highlights all yield points for that async context

-1. if on a `return` or `fn` keyword, `?` character or `->` return type arrow, highlights all exit points for that context

-1. if on a `break`, `loop`, `while` or `for` token, highlights all break points for that loop or block context

-1. 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](crates/ide/src/hover.rs#116)

-

-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](crates/ide/src/inlay_hints.rs#41)

-

-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](https://github.com/rust-lang/rust-analyzer/blob/6b8b8ff4c56118ddee6c531cde06add1aad4a6af/crates/ide/src/inlay_hints/param_name.rs#L92-L99)

-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](https://github.com/rust-lang/rust-analyzer/blob/6b8b8ff4c56118ddee6c531cde06add1aad4a6af/crates/ide/src/inlay_hints/param_name.rs#L200)

-in a unary function

-* the parameter name is a

-[single character](https://github.com/rust-lang/rust-analyzer/blob/6b8b8ff4c56118ddee6c531cde06add1aad4a6af/crates/ide/src/inlay_hints/param_name.rs#L201)

-in a unary function

-

-

-

-

-### Interpret A Function, Static Or Const.

-**Source:** [interpret.rs](crates/ide/src/interpret.rs#8)

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Interpret** |

-

-

-### Join Lines

-**Source:** [join_lines.rs](crates/ide/src/join_lines.rs#20)

-

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

-

-See [this gif](https://user-images.githubusercontent.com/1711539/124515923-4504e800-dde9-11eb-8d58-d97945a1a785.gif) for the cases handled specially by joined lines.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Join lines** |

-

-

-

-

-### Magic Completions

-**Source:** [lib.rs](crates/ide-completion/src/lib.rs#78)

-

-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` ->

-```rust

-#[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](crates/ide/src/matching_brace.rs#6)

-

-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.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Find matching brace** |

-

-

-

-

-### Memory Usage

-**Source:** [apply_change.rs](crates/ide-db/src/apply_change.rs#43)

-

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

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Memory Usage (Clears Database)**

-

-

-### Move Item

-**Source:** [move_item.rs](crates/ide/src/move_item.rs#16)

-

-Move item under cursor or selection up and down.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Move item up**

-| VS Code | **rust-analyzer: Move item down**

-

-

-

-

-### On Enter

-**Source:** [on_enter.rs](crates/ide/src/typing/on_enter.rs#17)

-

-rust-analyzer can override <kbd>Enter</kbd> key to make it smarter:

-

-- <kbd>Enter</kbd> inside triple-slash comments automatically inserts `///`

-- <kbd>Enter</kbd> in the middle or after a trailing space in `//` inserts `//`

-- <kbd>Enter</kbd> inside `//!` doc comments automatically inserts `//!`

-- <kbd>Enter</kbd> 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`:

-```json

-{

- "key": "Enter",

- "command": "rust-analyzer.onEnter",

- "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust"

-}

-````

-

-When using the Vim plugin:

-```json

-{

- "key": "Enter",

- "command": "rust-analyzer.onEnter",

- "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust && vim.mode == 'Insert'"

-}

-````

-

-

-

-

-### On Typing Assists

-**Source:** [typing.rs](crates/ide/src/typing.rs#42)

-

-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`:

-```json

-"editor.formatOnType": true,

-```

-

-

-

-

-

-### Open Docs

-**Source:** [doc_links.rs](crates/ide/src/doc_links.rs#118)

-

-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**.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Open Docs** |

-

-

-### Parent Module

-**Source:** [parent_module.rs](crates/ide/src/parent_module.rs#14)

-

-Navigates to the parent module of the current module.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Locate parent module** |

-

-

-

-

-### Related Tests

-**Source:** [runnables.rs](crates/ide/src/runnables.rs#202)

-

-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**.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Peek Related Tests** |

-

-

-### Rename

-**Source:** [rename.rs](crates/ide/src/rename.rs#70)

-

-Renames the item below the cursor and all of its references

-

-| Editor | Shortcut |

-|---------|----------|

-| VS Code | <kbd>F2</kbd> |

-

-

-

-

-### Run

-**Source:** [runnables.rs](crates/ide/src/runnables.rs#116)

-

-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!

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Run** |

-

-

-

-

-### Semantic Syntax Highlighting

-**Source:** [syntax_highlighting.rs](crates/ide/src/syntax_highlighting.rs#68)

-

-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:

-

-| | |

-|-----------|--------------------------------|

-| attribute | Emitted for attribute macros. |

-|enum| Emitted for enums. |

-|function| Emitted for free-standing functions. |

-|derive| Emitted for derive macros. |

-|macro| Emitted for function-like macros. |

-|method| Emitted for associated functions, also knowns as methods. |

-|namespace| Emitted for modules. |

-|struct| Emitted for structs.|

-|trait| Emitted for traits.|

-|typeAlias| Emitted for type aliases and `Self` in `impl`s.|

-|union| Emitted for unions.|

-

-- For literals:

-

-| | |

-|-----------|--------------------------------|

-| boolean| Emitted for the boolean literals `true` and `false`.|

-| character| Emitted for character literals.|

-| number| Emitted for numeric literals.|

-| string| Emitted for string literals.|

-| escapeSequence| Emitted for escaped sequences inside strings like `\n`.|

-| formatSpecifier| Emitted for format specifiers `{:?}` in `format!`-like macros.|

-

-- For operators:

-

-| | |

-|-----------|--------------------------------|

-|operator| Emitted for general operators.|

-|arithmetic| Emitted for the arithmetic operators `+`, `-`, `*`, `/`, `+=`, `-=`, `*=`, `/=`.|

-|bitwise| Emitted for the bitwise operators `|`, `&`, `!`, `^`, `|=`, `&=`, `^=`.|

-|comparison| Emitted for the comparison oerators `>`, `<`, `==`, `>=`, `<=`, `!=`.|

-|logical| Emitted for the logical operatos `||`, `&&`, `!`.|

-

-- For punctuation:

-

-| | |

-|-----------|--------------------------------|

-|punctuation| Emitted for general punctuation.|

-|attributeBracket| Emitted for attribute invocation brackets, that is the `#[` and `]` tokens.|

-|angle| Emitted for `<>` angle brackets.|

-|brace| Emitted for `{}` braces.|

-|bracket| Emitted for `[]` brackets.|

-|parenthesis| Emitted for `()` parentheses.|

-|colon| Emitted for the `:` token.|

-|comma| Emitted for the `,` token.|

-|dot| Emitted for the `.` token.|

-|semi| Emitted for the `;` token.|

-|macroBang| Emitted for the `!` token in macro calls.|

-

--

-

-| | |

-|-----------|--------------------------------|

-|builtinAttribute| Emitted for names to builtin attributes in attribute path, the `repr` in `#[repr(u8)]` for example.|

-|builtinType| Emitted for builtin types like `u32`, `str` and `f32`.|

-|comment| Emitted for comments.|

-|constParameter| Emitted for const parameters.|

-|deriveHelper| Emitted for derive helper attributes.|

-|enumMember| Emitted for enum variants.|

-|generic| Emitted for generic tokens that have no mapping.|

-|keyword| Emitted for keywords.|

-|label| Emitted for labels.|

-|lifetime| Emitted for lifetimes.|

-|parameter| Emitted for non-self function parameters.|

-|property| Emitted for struct and union fields.|

-|selfKeyword| Emitted for the self function parameter and self path-specifier.|

-|selfTypeKeyword| Emitted for the Self type parameter.|

-|toolModule| Emitted for tool modules.|

-|typeParameter| Emitted for type parameters.|

-|unresolvedReference| Emitted for unresolved references, names that rust-analyzer can't find the definition of.|

-|variable| Emitted for locals, constants and statics.|

-

-

-#### Token Modifiers

-

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

-

-Rust-analyzer currently emits the following token modifiers:

-

-| | |

-|-----------|--------------------------------|

-|async| Emitted for async functions and the `async` and `await` keywords.|

-|attribute| Emitted for tokens inside attributes.|

-|callable| Emitted for locals whose types implements one of the `Fn*` traits.|

-|constant| Emitted for const.|

-|consuming| Emitted for locals that are being consumed when use in a function call.|

-|controlFlow| Emitted for control-flow related tokens, this includes th `?` operator.|

-|crateRoot| Emitted for crate names, like `serde` and `crate.|

-|declaration| Emitted for names of definitions, like `foo` in `fn foo(){}`.|

-|defaultLibrary| Emitted for items from built-in crates (std, core, allc, test and proc_macro).|

-|documentation| Emitted for documentation comment.|

-|injected| Emitted for doc-string injected highlighting like rust source blocks in documentation.|

-|intraDocLink| Emitted for intra doc links in doc-string.|

-|library| Emitted for items that are defined outside of the current crae.|

-|macro| Emitted for tokens inside macro call.|

-|mutable| Emitted for mutable locals and statics as well as functions taking `&mut self`.|

-|public| Emitted for items that are from the current crate and are `pub.|

-|reference| Emitted for locals behind a reference and functions taking self` by reference.|

-|static| Emitted for "static" functions, also known as functions that d not take a `self` param, as well as statics and consts.|

-|trait| Emitted for associated trait item.|

-|unsafe| Emitted for unsafe operations, like unsafe function calls, as ell as the `unsafe` token.|

-

-

-

-

-

-### Show Dependency Tree

-**Source:** [fetch_crates.rs](crates/ide/src/fetch_crates.rs#13)

-

-Shows a view tree with all the dependencies of this project

-

-| Editor | Panel Name |

-|---------|------------|

-| VS Code | **Rust Dependencies** |

-

-

-

-

-### Show Syntax Tree

-**Source:** [view_syntax_tree.rs](crates/ide/src/view_syntax_tree.rs#14)

-

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

-

-| Editor | Panel Name |

-|---------|-------------|

-| VS Code | **Rust Syntax Tree** |

-

-

-### Status

-**Source:** [status.rs](crates/ide/src/status.rs#28)

-

-Shows internal statistic about memory usage of rust-analyzer.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: Status** |

-

-

-

-

-### Structural Search and Replace

-**Source:** [lib.rs](crates/ide-ssr/src/lib.rs#6)

-

-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:

-

-| Constraint | Restricts placeholder |

-|---------------|------------------------|

-| kind(literal) | Is a literal (e.g. `42` or `"forty two"`) |

-| not(a) | Negates the constraint `a` |

-

-Available via the command `rust-analyzer.ssr`.

-

-```rust

-// 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))

-```

-

-| Editor | Action Name |

-|---------|--------------|

-| VS Code | **rust-analyzer: Structural Search Replace** |

-

-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.

-

-```rust

-// Place the cursor on the line below to see the assist 💡.

-// foo($a, $b) ==>> ($a).foo($b)

-```

-

-

-### User Snippet Completions

-**Source:** [snippet.rs](crates/ide-completion/src/snippet.rs#5)

-

-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.

-

-```json

-{

- "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](crates/ide/src/view_crate_graph.rs#8)

-

-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.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: View Crate Graph** |

-

-

-### View Hir

-**Source:** [view_hir.rs](crates/ide/src/view_hir.rs#5)

-

-| Editor | Action Name |

-|---------|--------------|

-| VS Code | **rust-analyzer: View Hir**

-

-

-

-

-### View Memory Layout

-**Source:** [view_memory_layout.rs](crates/ide/src/view_memory_layout.rs#74)

-

-Displays the recursive memory layout of a datatype.

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: View Memory Layout** |

-

-

-### View Mir

-**Source:** [view_mir.rs](crates/ide/src/view_mir.rs#5)

-

-| Editor | Action Name |

-|---------|-------------|

-| VS Code | **rust-analyzer: View Mir**

-

-

-### Workspace Symbol

-**Source:** [symbol_index.rs](crates/ide-db/src/symbol_index.rs#174)

-

-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.

-

-| Editor | Shortcut |

-|---------|-----------|

-| VS Code | <kbd>Ctrl+T</kbd>