]> git.lizzy.rs Git - rust.git/blob - docs/user/features.md
move all assists to use generated docs
[rust.git] / docs / user / features.md
1 This documents is an index of features that rust-analyzer language server
2 provides. Shortcuts are for the default VS Code layout. If there's no shortcut,
3 you can use <kbd>Ctrl+Shift+P</kbd> to search for the corresponding action.
4
5 ### Workspace Symbol <kbd>ctrl+t</kbd>
6
7 Uses fuzzy-search to find types, modules and function by name across your
8 project and dependencies. This is **the** most useful feature, which improves code
9 navigation tremendously. It mostly works on top of the built-in LSP
10 functionality, however `#` and `*` symbols can be used to narrow down the
11 search. Specifically,
12
13 - `Foo` searches for `Foo` type in the current workspace
14 - `foo#` searches for `foo` function in the current workspace
15 - `Foo*` searches for `Foo` type among dependencies, including `stdlib`
16 - `foo#*` searches for `foo` function among dependencies.
17
18 That is, `#` switches from "types" to all symbols, `*` switches from the current
19 workspace to dependencies.
20
21 ### Document Symbol <kbd>ctrl+shift+o</kbd>
22
23 Provides a tree of the symbols defined in the file. Can be used to
24
25 * fuzzy search symbol in a file (super useful)
26 * draw breadcrumbs to describe the context around the cursor
27 * draw outline of the file
28
29 ### On Typing Assists
30
31 Some features trigger on typing certain characters:
32
33 - typing `let =` tries to smartly add `;` if `=` is followed by an existing expression.
34 - Enter inside comments automatically inserts `///`
35 - typing `.` in a chain method call auto-indents
36
37 ### Extend Selection
38
39 Extends the current selection to the encompassing syntactic construct
40 (expression, statement, item, module, etc). It works with multiple cursors. This
41 is a relatively new feature of LSP:
42 https://github.com/Microsoft/language-server-protocol/issues/613, check your
43 editor's LSP library to see if this feature is supported.
44
45 ### Go to Definition
46
47 Navigates to the definition of an identifier.
48
49 ### Go to Implementation
50
51 Navigates to the impl block of structs, enums or traits. Also implemented as a code lens.
52
53 ### Go to Type Defintion
54
55 Navigates to the type of an identifier.
56
57 ### Commands <kbd>ctrl+shift+p</kbd>
58
59 #### Run
60
61 Shows popup suggesting to run a test/benchmark/binary **at the current cursor
62 location**. Super useful for repeatedly running just a single test. Do bind this
63 to a shortcut!
64
65 #### Parent Module
66
67 Navigates to the parent module of the current module.
68
69 #### Matching Brace
70
71 If the cursor is on any brace (`<>(){}[]`) which is a part of a brace-pair,
72 moves cursor to the matching brace. It uses the actual parser to determine
73 braces, so it won't confuse generics with comparisons.
74
75 #### Join Lines
76
77 Join selected lines into one, smartly fixing up whitespace and trailing commas.
78
79 #### Show Syntax Tree
80
81 Shows the parse tree of the current file. It exists mostly for debugging
82 rust-analyzer itself.
83
84 #### Status
85
86 Shows internal statistic about memory usage of rust-analyzer
87
88 #### Run garbage collection
89
90 Manually triggers GC
91
92 #### Start Cargo Watch
93
94 Start `cargo watch` for live error highlighting. Will prompt to install if it's not already installed.
95
96 #### Stop Cargo Watch
97
98 Stop `cargo watch`
99
100 ### Assists (Code Actions)
101
102 Assists, or code actions, are small local refactorings, available in a particular context.
103 They are usually triggered by a shortcut or by clicking a light bulb icon in the editor.
104
105 See [assists.md](./assists.md) for the list of available assists.
106
107 ### Magic Completions
108
109 In addition to usual reference completion, rust-analyzer provides some ✨magic✨
110 completions as well:
111
112 Keywords like `if`, `else` `while`, `loop` are completed with braces, and cursor
113 is placed at the appropriate position. Even though `if` is easy to type, you
114 still want to complete it, to get ` { }` for free! `return` is inserted with a
115 space or `;` depending on the return type of the function.
116
117 When completing a function call, `()` are automatically inserted. If function
118 takes arguments, cursor is positioned inside the parenthesis.
119
120 There are postifx completions, which can be triggerd by typing something like
121 `foo().if`. The word after `.` determines postifx completion, possible variants are:
122
123 - `expr.if` -> `if expr {}`
124 - `expr.match` -> `match expr {}`
125 - `expr.while` -> `while expr {}`
126 - `expr.ref` -> `&expr`
127 - `expr.refm` -> `&mut expr`
128 - `expr.not` -> `!expr`
129 - `expr.dbg` -> `dbg!(expr)`
130
131 There also snippet completions:
132
133 #### Inside Expressions
134
135 - `pd` -> `println!("{:?}")`
136 - `ppd` -> `println!("{:#?}")`
137
138 #### Inside Modules
139
140 - `tfn` -> `#[test] fn f(){}`
141
142 ### Code highlighting
143
144 Experimental feature to let rust-analyzer highlight Rust code instead of using the
145 default highlighter.
146
147 #### Rainbow highlighting
148
149 Experimental feature that, given code highlighting using rust-analyzer is
150 active, will pick unique colors for identifiers.