document assists

1 files changed, 203 insertions, 48 deletions

diff --git a/docs/user/features.md b/docs/user/features.md
index 5df606aee03..aa3bf5157e0 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -1,45 +1,47 @@
-This documents is an index of features that rust-analyzer language server provides.
+This documents is an index of features that rust-analyzer language server
+provides. Shortcuts are for the default VS Code layout. If there's no shortcut,
+you can use <kbd>Ctrl+Shift+P</kbd> to search for the corresponding action.
 
-### Go to symbol in workspace <kbd>ctrl+t</kbd>
+### Workspace Symbol <kbd>ctrl+t</kbd>
 
-It mostly works on top of the built-in LSP functionality, however `#` and `*`
-symbols can be used to narrow down the search. Specifically,
+Uses fuzzy-search to find types, modules and function by name across your
+project and dependencies. This **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, excluding `stdlib`
-- `#foo#*` searches for `foo` function among dependencies.
+- `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, excluding `stdlib`
+- `foo#*` searches for `foo` function among dependencies.
 
 That is, `#` switches from "types" to all symbols, `*` switches from the current
 workspace to dependencies.
 
-### Commands <kbd>ctrl+shift+p</kbd>
-
-#### Show Rust Syntax Tree
-
-Shows the parse tree of the current file. It exists mostly for debugging
-rust-analyzer itself.
+### Document Symbol <kbd>ctrl+shift+o</kbd>
 
-#### Extend Selection
+Provides a tree of the symbols defined in the file. Can be used to
 
-Extends the current selection to the encompassing syntactic construct
-(expression, statement, item, module, etc). It works with multiple cursors. Do
-bind this command to a key, its super-useful! Expected to be upstreamed to LSP soonish:
-https://github.com/Microsoft/language-server-protocol/issues/613
+* fuzzy search symbol in a file (super useful)
+* draw breadcrumbs to describe the context around the cursor
+* draw outline of the file
 
-#### Matching Brace
+### On Typing Assists
 
-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.
+Some features trigger on typing certain characters:
 
-#### Parent Module
+- typing `let =` tries to smartly add `;` if `=` is followed by an existing expression.
+- Enter inside comments automatically inserts `///`
+- typing `.` in a chain method call auto-indents
 
-Navigates to the parent module of the current module.
+### Commands <kbd>ctrl+shift+p</kbd>
 
-#### Join Lines
+#### Extend Selection
 
-Join selected lines into one, smartly fixing up whitespace and trailing commas.
+Extends the current selection to the encompassing syntactic construct
+(expression, statement, item, module, etc). It works with multiple cursors. Do
+bind this command to a key, it's super-useful! Expected to be upstreamed to LSP
+soonish: https://github.com/Microsoft/language-server-protocol/issues/613
 
 #### Run
 
@@ -47,33 +49,37 @@ Shows 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!
 
+#### Parent Module
 
-### On Typing Assists
+Navigates to the parent module of the current module.
 
-Some features trigger on typing certain characters:
+#### Matching Brace
 
-- typing `let =` tries to smartly add `;` if `=` is followed by an existing expression.
-- Enter inside comments automatically inserts `///`
-- typing `.` in a chain method call auto-indents
+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.
 
+#### Join Lines
 
+Join selected lines into one, smartly fixing up whitespace and trailing commas.
 
+#### Show Syntax Tree
 
+Shows the parse tree of the current file. It exists mostly for debugging
+rust-analyzer itself.
 
-### Code Actions (Assists)
+#### Status
 
-These are triggered in a particular context via light bulb. We use custom code on
-the VS Code side to be able to position cursor.
+Shows internal statistic about memory usage of rust-analyzer
 
+#### Run garbage collection
 
-- Flip `,`
+Manually triggers GC
 
-```rust
-// before:
-fn foo(x: usize,<|> dim: (usize, usize))
-// after:
-fn foo(dim: (usize, usize), x: usize)
-```
+### Code Actions (Assists)
+
+These are triggered in a particular context via light bulb. We use custom code on
+the VS Code side to be able to position cursor. `<|>` signifies cursor
 
 - Add `#[derive]`
 
@@ -106,14 +112,147 @@ impl<'a, T: Debug> Foo<'a, T> {
 }
 ```
 
-- Change visibility
+- Add missing `impl` members
 
 ```rust
 // before:
-fn<|> foo() {}
+trait Foo {
+    fn foo(&self);
+    fn bar(&self);
+    fn baz(&self);
+}
+
+struct S;
+
+impl Foo for S {
+    fn bar(&self) {}
+    <|>
+}
+
+// after:
+trait Foo {
+    fn foo(&self);
+    fn bar(&self);
+    fn baz(&self);
+}
 
-// after
-pub(crate) fn foo() {}
+struct S;
+
+impl Foo for S {
+    fn bar(&self) {}
+    fn foo(&self) { unimplemented!() }
+    fn baz(&self) { unimplemented!() }<|>
+}
+```
+
+- Import path
+
+```rust
+// before:
+impl std::fmt::Debug<|> for Foo {
+}
+
+// after:
+use std::fmt::Debug
+
+impl Debug<|> for Foo {
+}
+```
+
+- Change Visibility
+
+```rust
+// before:
+<|>fn foo() {}
+
+// after:
+<|>pub(crate) fn foo() {}
+
+// after:
+<|>pub fn foo() {}
+```
+
+- Fill match arms
+
+```rust
+// before:
+enum A {
+    As,
+    Bs,
+    Cs(String),
+    Ds(String, String),
+    Es{x: usize, y: usize}
+}
+
+fn main() {
+    let a = A::As;
+    match a<|> {}
+}
+
+// after:
+enum A {
+    As,
+    Bs,
+    Cs(String),
+    Ds(String, String),
+    Es{x: usize, y: usize}
+}
+
+fn main() {
+    let a = A::As;
+    match <|>a {
+        A::As => (),
+        A::Bs => (),
+        A::Cs(_) => (),
+        A::Ds(_, _) => (),
+        A::Es{x, y} => (),
+    }
+}
+```
+
+-- Fill struct fields
+
+```rust
+// before:
+struct S<'a, D> {
+    a: u32,
+    b: String,
+    c: (i32, i32),
+    d: D,
+    r: &'a str,
+}
+
+fn main() {
+    let s = S<|> {}
+}
+
+// after:
+struct S<'a, D> {
+    a: u32,
+    b: String,
+    c: (i32, i32),
+    d: D,
+    r: &'a str,
+}
+
+fn main() {
+    let s = <|>S {
+        a: (),
+        b: (),
+        c: (),
+        d: (),
+        r: (),
+    }
+}
+```
+
+- Flip `,`
+
+```rust
+// before:
+fn foo(x: usize,<|> dim: (usize, usize)) {}
+// after:
+fn foo(dim: (usize, usize), x: usize) {}
 ```
 
 - Introduce variable:
@@ -131,6 +270,24 @@ fn foo() {
 }
 ```
 
+-- Remove `dbg!`
+
+```rust
+// before:
+fn foo(n: usize) {
+    if let Some(_) = dbg!(n.<|>checked_sub(4)) {
+        // ...
+    }
+}
+
+// after:
+fn foo(n: usize) {
+    if let Some(_) = n.<|>checked_sub(4) {
+        // ...
+    }
+}
+```
+
 - Replace if-let with match:
 
 ```rust
@@ -164,5 +321,3 @@ use algo:<|>:visitor::{Visitor, visit};
 //after:
 use algo::{<|>visitor::{Visitor, visit}};
 ```
-
-