5 files changed, 1373 insertions, 934 deletions

diff --git a/docs/user/assists.md b/docs/user/assists.md
deleted file mode 100644
index 6c6943622..000000000
--- a/docs/user/assists.md
+++ /dev/null
@@ -1,697 +0,0 @@
-# Assists
-
-Cursor position or selection is signified by `┃` character.
-
-
-## `add_custom_impl`
-
-Adds impl block for derived trait.
-
-```rust
-// BEFORE
-#[derive(Deb┃ug, Display)]
-struct S;
-
-// AFTER
-#[derive(Display)]
-struct S;
-
-impl Debug for S {
-
-}
-```
-
-## `add_derive`
-
-Adds a new `#[derive()]` clause to a struct or enum.
-
-```rust
-// BEFORE
-struct Point {
-    x: u32,
-    y: u32,┃
-}
-
-// AFTER
-#[derive()]
-struct Point {
-    x: u32,
-    y: u32,
-}
-```
-
-## `add_explicit_type`
-
-Specify type for a let binding.
-
-```rust
-// BEFORE
-fn main() {
-    let x┃ = 92;
-}
-
-// AFTER
-fn main() {
-    let x: i32 = 92;
-}
-```
-
-## `add_function`
-
-Adds a stub function with a signature matching the function under the cursor.
-
-```rust
-// BEFORE
-struct Baz;
-fn baz() -> Baz { Baz }
-fn foo() {
-    bar┃("", baz());
-}
-
-
-// AFTER
-struct Baz;
-fn baz() -> Baz { Baz }
-fn foo() {
-    bar("", baz());
-}
-
-fn bar(arg: &str, baz: Baz) {
-    todo!()
-}
-
-```
-
-## `add_hash`
-
-Adds a hash to a raw string literal.
-
-```rust
-// BEFORE
-fn main() {
-    r#"Hello,┃ World!"#;
-}
-
-// AFTER
-fn main() {
-    r##"Hello, World!"##;
-}
-```
-
-## `add_impl`
-
-Adds a new inherent impl for a type.
-
-```rust
-// BEFORE
-struct Ctx<T: Clone> {
-     data: T,┃
-}
-
-// AFTER
-struct Ctx<T: Clone> {
-     data: T,
-}
-
-impl<T: Clone> Ctx<T> {
-
-}
-```
-
-## `add_impl_default_members`
-
-Adds scaffold for overriding default impl members.
-
-```rust
-// BEFORE
-trait Trait {
-    Type X;
-    fn foo(&self);
-    fn bar(&self) {}
-}
-
-impl Trait for () {
-    Type X = ();
-    fn foo(&self) {}┃
-
-}
-
-// AFTER
-trait Trait {
-    Type X;
-    fn foo(&self);
-    fn bar(&self) {}
-}
-
-impl Trait for () {
-    Type X = ();
-    fn foo(&self) {}
-    fn bar(&self) {}
-
-}
-```
-
-## `add_impl_missing_members`
-
-Adds scaffold for required impl members.
-
-```rust
-// BEFORE
-trait Trait<T> {
-    Type X;
-    fn foo(&self) -> T;
-    fn bar(&self) {}
-}
-
-impl Trait<u32> for () {┃
-
-}
-
-// AFTER
-trait Trait<T> {
-    Type X;
-    fn foo(&self) -> T;
-    fn bar(&self) {}
-}
-
-impl Trait<u32> for () {
-    fn foo(&self) -> u32 { todo!() }
-
-}
-```
-
-## `add_new`
-
-Adds a new inherent impl for a type.
-
-```rust
-// BEFORE
-struct Ctx<T: Clone> {
-     data: T,┃
-}
-
-// AFTER
-struct Ctx<T: Clone> {
-     data: T,
-}
-
-impl<T: Clone> Ctx<T> {
-    fn new(data: T) -> Self { Self { data } }
-}
-
-```
-
-## `apply_demorgan`
-
-Apply [De Morgan's law](https://en.wikipedia.org/wiki/De_Morgan%27s_laws).
-This transforms expressions of the form `!l || !r` into `!(l && r)`.
-This also works with `&&`. This assist can only be applied with the cursor
-on either `||` or `&&`, with both operands being a negation of some kind.
-This means something of the form `!x` or `x != y`.
-
-```rust
-// BEFORE
-fn main() {
-    if x != 4 ||┃ !y {}
-}
-
-// AFTER
-fn main() {
-    if !(x == 4 && y) {}
-}
-```
-
-## `auto_import`
-
-If the name is unresolved, provides all possible imports for it.
-
-```rust
-// BEFORE
-fn main() {
-    let map = HashMap┃::new();
-}
-
-// AFTER
-use std::collections::HashMap;
-
-fn main() {
-    let map = HashMap::new();
-}
-```
-
-## `change_visibility`
-
-Adds or changes existing visibility specifier.
-
-```rust
-// BEFORE
-┃fn frobnicate() {}
-
-// AFTER
-pub(crate) fn frobnicate() {}
-```
-
-## `convert_to_guarded_return`
-
-Replace a large conditional with a guarded return.
-
-```rust
-// BEFORE
-fn main() {
-    ┃if cond {
-        foo();
-        bar();
-    }
-}
-
-// AFTER
-fn main() {
-    if !cond {
-        return;
-    }
-    foo();
-    bar();
-}
-```
-
-## `fill_match_arms`
-
-Adds missing clauses to a `match` expression.
-
-```rust
-// BEFORE
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        ┃
-    }
-}
-
-// AFTER
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move { distance } => {}
-        Action::Stop => {}
-    }
-}
-```
-
-## `flip_binexpr`
-
-Flips operands of a binary expression.
-
-```rust
-// BEFORE
-fn main() {
-    let _ = 90 +┃ 2;
-}
-
-// AFTER
-fn main() {
-    let _ = 2 + 90;
-}
-```
-
-## `flip_comma`
-
-Flips two comma-separated items.
-
-```rust
-// BEFORE
-fn main() {
-    ((1, 2),┃ (3, 4));
-}
-
-// AFTER
-fn main() {
-    ((3, 4), (1, 2));
-}
-```
-
-## `flip_trait_bound`
-
-Flips two trait bounds.
-
-```rust
-// BEFORE
-fn foo<T: Clone +┃ Copy>() { }
-
-// AFTER
-fn foo<T: Copy + Clone>() { }
-```
-
-## `inline_local_variable`
-
-Inlines local variable.
-
-```rust
-// BEFORE
-fn main() {
-    let x┃ = 1 + 2;
-    x * 4;
-}
-
-// AFTER
-fn main() {
-    (1 + 2) * 4;
-}
-```
-
-## `introduce_variable`
-
-Extracts subexpression into a variable.
-
-```rust
-// BEFORE
-fn main() {
-    ┃(1 + 2)┃ * 4;
-}
-
-// AFTER
-fn main() {
-    let var_name = (1 + 2);
-    var_name * 4;
-}
-```
-
-## `invert_if`
-
-Apply invert_if
-This transforms if expressions of the form `if !x {A} else {B}` into `if x {B} else {A}`
-This also works with `!=`. This assist can only be applied with the cursor
-on `if`.
-
-```rust
-// BEFORE
-fn main() {
-    if┃ !y { A } else { B }
-}
-
-// AFTER
-fn main() {
-    if y { B } else { A }
-}
-```
-
-## `make_raw_string`
-
-Adds `r#` to a plain string literal.
-
-```rust
-// BEFORE
-fn main() {
-    "Hello,┃ World!";
-}
-
-// AFTER
-fn main() {
-    r#"Hello, World!"#;
-}
-```
-
-## `make_usual_string`
-
-Turns a raw string into a plain string.
-
-```rust
-// BEFORE
-fn main() {
-    r#"Hello,┃ "World!""#;
-}
-
-// AFTER
-fn main() {
-    "Hello, \"World!\"";
-}
-```
-
-## `merge_imports`
-
-Merges two imports with a common prefix.
-
-```rust
-// BEFORE
-use std::┃fmt::Formatter;
-use std::io;
-
-// AFTER
-use std::{fmt::Formatter, io};
-```
-
-## `merge_match_arms`
-
-Merges identical match arms.
-
-```rust
-// BEFORE
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        ┃Action::Move(..) => foo(),
-        Action::Stop => foo(),
-    }
-}
-
-// AFTER
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move(..) | Action::Stop => foo(),
-    }
-}
-```
-
-## `move_arm_cond_to_match_guard`
-
-Moves if expression from match arm body into a guard.
-
-```rust
-// BEFORE
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move { distance } => ┃if distance > 10 { foo() },
-        _ => (),
-    }
-}
-
-// AFTER
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move { distance } if distance > 10 => foo(),
-        _ => (),
-    }
-}
-```
-
-## `move_bounds_to_where_clause`
-
-Moves inline type bounds to a where clause.
-
-```rust
-// BEFORE
-fn apply<T, U, ┃F: FnOnce(T) -> U>(f: F, x: T) -> U {
-    f(x)
-}
-
-// AFTER
-fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U {
-    f(x)
-}
-```
-
-## `move_guard_to_arm_body`
-
-Moves match guard into match arm body.
-
-```rust
-// BEFORE
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move { distance } ┃if distance > 10 => foo(),
-        _ => (),
-    }
-}
-
-// AFTER
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move { distance } => if distance > 10 { foo() },
-        _ => (),
-    }
-}
-```
-
-## `remove_dbg`
-
-Removes `dbg!()` macro call.
-
-```rust
-// BEFORE
-fn main() {
-    ┃dbg!(92);
-}
-
-// AFTER
-fn main() {
-    92;
-}
-```
-
-## `remove_hash`
-
-Removes a hash from a raw string literal.
-
-```rust
-// BEFORE
-fn main() {
-    r#"Hello,┃ World!"#;
-}
-
-// AFTER
-fn main() {
-    r"Hello, World!";
-}
-```
-
-## `remove_mut`
-
-Removes the `mut` keyword.
-
-```rust
-// BEFORE
-impl Walrus {
-    fn feed(&mut┃ self, amount: u32) {}
-}
-
-// AFTER
-impl Walrus {
-    fn feed(&self, amount: u32) {}
-}
-```
-
-## `reorder_fields`
-
-Reorder the fields of record literals and record patterns in the same order as in
-the definition.
-
-```rust
-// BEFORE
-struct Foo {foo: i32, bar: i32};
-const test: Foo = ┃Foo {bar: 0, foo: 1}
-
-// AFTER
-struct Foo {foo: i32, bar: i32};
-const test: Foo = Foo {foo: 1, bar: 0}
-```
-
-## `replace_if_let_with_match`
-
-Replaces `if let` with an else branch with a `match` expression.
-
-```rust
-// BEFORE
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    ┃if let Action::Move { distance } = action {
-        foo(distance)
-    } else {
-        bar()
-    }
-}
-
-// AFTER
-enum Action { Move { distance: u32 }, Stop }
-
-fn handle(action: Action) {
-    match action {
-        Action::Move { distance } => foo(distance),
-        _ => bar(),
-    }
-}
-```
-
-## `replace_let_with_if_let`
-
-Replaces `let` with an `if-let`.
-
-```rust
-// BEFORE
-
-fn main(action: Action) {
-    ┃let x = compute();
-}
-
-fn compute() -> Option<i32> { None }
-
-// AFTER
-
-fn main(action: Action) {
-    if let Some(x) = compute() {
-    }
-}
-
-fn compute() -> Option<i32> { None }
-```
-
-## `replace_qualified_name_with_use`
-
-Adds a use statement for a given fully-qualified name.
-
-```rust
-// BEFORE
-fn process(map: std::collections::┃HashMap<String, String>) {}
-
-// AFTER
-use std::collections::HashMap;
-
-fn process(map: HashMap<String, String>) {}
-```
-
-## `replace_unwrap_with_match`
-
-Replaces `unwrap` a `match` expression. Works for Result and Option.
-
-```rust
-// BEFORE
-enum Result<T, E> { Ok(T), Err(E) }
-fn main() {
-    let x: Result<i32, i32> = Result::Ok(92);
-    let y = x.┃unwrap();
-}
-
-// AFTER
-enum Result<T, E> { Ok(T), Err(E) }
-fn main() {
-    let x: Result<i32, i32> = Result::Ok(92);
-    let y = match x {
-        Ok(a) => a,
-        _ => unreachable!(),
-    };
-}
-```
-
-## `split_import`
-
-Wraps the tail of import into braces.
-
-```rust
-// BEFORE
-use std::┃collections::HashMap;
-
-// AFTER
-use std::{collections::HashMap};
-```
diff --git a/docs/user/features.md b/docs/user/features.md
deleted file mode 100644
index b9a365fc1..000000000
--- a/docs/user/features.md
+++ /dev/null
@@ -1,202 +0,0 @@
-This document is an index of features that the 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.
-
-### Workspace Symbol <kbd>ctrl+t</kbd>
-
-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.
-
-### Document Symbol <kbd>ctrl+shift+o</kbd>
-
-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
-
-### On Typing Assists
-
-Some features trigger on typing certain characters:
-
-- 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
-
-### Extend Selection
-
-Extends the current selection to the encompassing syntactic construct
-(expression, statement, item, module, etc). It works with multiple cursors. This
-is a relatively new feature of LSP:
-https://github.com/Microsoft/language-server-protocol/issues/613, check your
-editor's LSP library to see if this feature is supported.
-
-### Go to Definition
-
-Navigates to the definition of an identifier.
-
-### Go to Implementation
-
-Navigates to the impl block of structs, enums or traits. Also implemented as a code lens.
-
-### Go to Type Defintion
-
-Navigates to the type of an identifier.
-
-### Commands <kbd>ctrl+shift+p</kbd>
-
-#### Run
-
-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!
-
-#### Parent Module
-
-Navigates to the parent module of the current module.
-
-#### Matching Brace
-
-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.
-
-#### Expand Macro Recursively
-
-Shows the full macro expansion of the macro at current cursor.
-
-#### Status
-
-Shows internal statistic about memory usage of rust-analyzer.
-
-#### Show RA Version
-
-Show current rust-analyzer version.
-
-#### Run Garbage Collection
-
-Manually triggers GC.
-
-#### Start Cargo Watch
-
-Start `cargo watch` for live error highlighting. Will prompt to install if it's not already installed.
-
-#### Stop Cargo Watch
-
-Stop `cargo watch`.
-
-#### Structural Seach and Replace
-
-Search and replace with named wildcards that will match any expression.
-The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`. A `$<name>:expr` placeholder in the search pattern will match any expression and `$<name>` will reference it in the replacement. Available via the command `rust-analyzer.ssr`.
-
-```rust
-// Using structural search replace command [foo($a:expr, $b:expr) ==>> ($a).foo($b)]
-
-// BEFORE
-String::from(foo(y + 5, z))
-
-// AFTER
-String::from((y + 5).foo(z))
-```
-
-### Assists (Code Actions)
-
-Assists, or code actions, are small local refactorings, available in a particular context.
-They are usually triggered by a shortcut or by clicking a light bulb icon in the editor.
-
-See [assists.md](./assists.md) for the list of available assists.
-
-### Magic Completions
-
-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 {}`
-- `expr.match` -> `match expr {}`
-- `expr.while` -> `while expr {}`
-- `expr.ref` -> `&expr`
-- `expr.refm` -> `&mut expr`
-- `expr.not` -> `!expr`
-- `expr.dbg` -> `dbg!(expr)`
-
-There also snippet completions:
-
-#### Inside Expressions
-
-- `pd` -> `println!("{:?}")`
-- `ppd` -> `println!("{:#?}")`
-
-#### Inside Modules
-
-- `tfn` -> `#[test] fn f(){}`
-
-### Code Highlighting
-
-Experimental feature to let rust-analyzer highlight Rust code instead of using the
-default highlighter.
-
-#### Rainbow Highlighting
-
-Experimental feature that, given code highlighting using rust-analyzer is
-active, will pick unique colors for identifiers.
-
-### Code hints
-
-Rust-analyzer has two types of hints to show the information about the code:
-
-* hover hints, appearing on hover on any element.
-
-These contain extended information on the hovered language item.
-
-* inlay hints, shown near the element hinted directly in the editor.
-
-Two types of inlay hints are displayed currently:
-
-* type hints, displaying the minimal information on the type of the expression (if the information is available)
-* method chaining hints, type information for multi-line method chains
-* parameter name hints, displaying the names of the parameters in the corresponding methods
-
-#### VS Code
-
-In VS Code, the following settings can be used to configure the inlay hints:
-
-* `rust-analyzer.inlayHints.typeHints` - enable hints for inferred types.
-* `rust-analyzer.inlayHints.chainingHints` - enable hints for inferred types on method chains.
-* `rust-analyzer.inlayHints.parameterHints` - enable hints for function parameters.
-* `rust-analyzer.inlayHints.maxLength` — shortens the hints if their length exceeds the value specified. If no value is specified (`null`), no shortening is applied.
-
-**Note:** VS Code does not have native support for inlay hints [yet](https://github.com/microsoft/vscode/issues/16221) and the hints are implemented using decorations.
-This approach has limitations, the caret movement and bracket highlighting near the edges of the hint may be weird:
-[1](https://github.com/rust-analyzer/rust-analyzer/issues/1623), [2](https://github.com/rust-analyzer/rust-analyzer/issues/3453).
diff --git a/docs/user/generated_assists.adoc b/docs/user/generated_assists.adoc
new file mode 100644
index 000000000..4d2fb31d4
--- /dev/null
+++ b/docs/user/generated_assists.adoc
@@ -0,0 +1,1015 @@
+[discrete]
+=== `add_custom_impl`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_custom_impl.rs#L14[add_custom_impl.rs]
+
+Adds impl block for derived trait.
+
+.Before
+```rust
+#[derive(Deb┃ug, Display)]
+struct S;
+```
+
+.After
+```rust
+#[derive(Display)]
+struct S;
+
+impl Debug for S {
+    $0
+}
+```
+
+
+[discrete]
+=== `add_derive`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_derive.rs#L9[add_derive.rs]
+
+Adds a new `#[derive()]` clause to a struct or enum.
+
+.Before
+```rust
+struct Point {
+    x: u32,
+    y: u32,┃
+}
+```
+
+.After
+```rust
+#[derive($0)]
+struct Point {
+    x: u32,
+    y: u32,
+}
+```
+
+
+[discrete]
+=== `add_explicit_type`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_explicit_type.rs#L9[add_explicit_type.rs]
+
+Specify type for a let binding.
+
+.Before
+```rust
+fn main() {
+    let x┃ = 92;
+}
+```
+
+.After
+```rust
+fn main() {
+    let x: i32 = 92;
+}
+```
+
+
+[discrete]
+=== `add_from_impl_for_enum`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs#L7[add_from_impl_for_enum.rs]
+
+Adds a From impl for an enum variant with one tuple field.
+
+.Before
+```rust
+enum A { ┃One(u32) }
+```
+
+.After
+```rust
+enum A { One(u32) }
+
+impl From<u32> for A {
+    fn from(v: u32) -> Self {
+        A::One(v)
+    }
+}
+```
+
+
+[discrete]
+=== `add_function`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_function.rs#L19[add_function.rs]
+
+Adds a stub function with a signature matching the function under the cursor.
+
+.Before
+```rust
+struct Baz;
+fn baz() -> Baz { Baz }
+fn foo() {
+    bar┃("", baz());
+}
+
+```
+
+.After
+```rust
+struct Baz;
+fn baz() -> Baz { Baz }
+fn foo() {
+    bar("", baz());
+}
+
+fn bar(arg: &str, baz: Baz) {
+    ${0:todo!()}
+}
+
+```
+
+
+[discrete]
+=== `add_hash`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L65[raw_string.rs]
+
+Adds a hash to a raw string literal.
+
+.Before
+```rust
+fn main() {
+    r#"Hello,┃ World!"#;
+}
+```
+
+.After
+```rust
+fn main() {
+    r##"Hello, World!"##;
+}
+```
+
+
+[discrete]
+=== `add_impl`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_impl.rs#L6[add_impl.rs]
+
+Adds a new inherent impl for a type.
+
+.Before
+```rust
+struct Ctx<T: Clone> {
+    data: T,┃
+}
+```
+
+.After
+```rust
+struct Ctx<T: Clone> {
+    data: T,
+}
+
+impl<T: Clone> Ctx<T> {
+    $0
+}
+```
+
+
+[discrete]
+=== `add_impl_default_members`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_missing_impl_members.rs#L64[add_missing_impl_members.rs]
+
+Adds scaffold for overriding default impl members.
+
+.Before
+```rust
+trait Trait {
+    Type X;
+    fn foo(&self);
+    fn bar(&self) {}
+}
+
+impl Trait for () {
+    Type X = ();
+    fn foo(&self) {}┃
+
+}
+```
+
+.After
+```rust
+trait Trait {
+    Type X;
+    fn foo(&self);
+    fn bar(&self) {}
+}
+
+impl Trait for () {
+    Type X = ();
+    fn foo(&self) {}
+    $0fn bar(&self) {}
+
+}
+```
+
+
+[discrete]
+=== `add_impl_missing_members`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_missing_impl_members.rs#L24[add_missing_impl_members.rs]
+
+Adds scaffold for required impl members.
+
+.Before
+```rust
+trait Trait<T> {
+    Type X;
+    fn foo(&self) -> T;
+    fn bar(&self) {}
+}
+
+impl Trait<u32> for () {┃
+
+}
+```
+
+.After
+```rust
+trait Trait<T> {
+    Type X;
+    fn foo(&self) -> T;
+    fn bar(&self) {}
+}
+
+impl Trait<u32> for () {
+    fn foo(&self) -> u32 {
+        ${0:todo!()}
+    }
+
+}
+```
+
+
+[discrete]
+=== `add_new`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_new.rs#L12[add_new.rs]
+
+Adds a new inherent impl for a type.
+
+.Before
+```rust
+struct Ctx<T: Clone> {
+     data: T,┃
+}
+```
+
+.After
+```rust
+struct Ctx<T: Clone> {
+     data: T,
+}
+
+impl<T: Clone> Ctx<T> {
+    fn $0new(data: T) -> Self { Self { data } }
+}
+
+```
+
+
+[discrete]
+=== `add_turbo_fish`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_turbo_fish.rs#L10[add_turbo_fish.rs]
+
+Adds `::<_>` to a call of a generic method or function.
+
+.Before
+```rust
+fn make<T>() -> T { todo!() }
+fn main() {
+    let x = make┃();
+}
+```
+
+.After
+```rust
+fn make<T>() -> T { todo!() }
+fn main() {
+    let x = make::<${0:_}>();
+}
+```
+
+
+[discrete]
+=== `apply_demorgan`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/apply_demorgan.rs#L5[apply_demorgan.rs]
+
+Apply [De Morgan's law](https://en.wikipedia.org/wiki/De_Morgan%27s_laws).
+This transforms expressions of the form `!l || !r` into `!(l && r)`.
+This also works with `&&`. This assist can only be applied with the cursor
+on either `||` or `&&`, with both operands being a negation of some kind.
+This means something of the form `!x` or `x != y`.
+
+.Before
+```rust
+fn main() {
+    if x != 4 ||┃ !y {}
+}
+```
+
+.After
+```rust
+fn main() {
+    if !(x == 4 && y) {}
+}
+```
+
+
+[discrete]
+=== `auto_import`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/auto_import.rs#L18[auto_import.rs]
+
+If the name is unresolved, provides all possible imports for it.
+
+.Before
+```rust
+fn main() {
+    let map = HashMap┃::new();
+}
+```
+
+.After
+```rust
+use std::collections::HashMap;
+
+fn main() {
+    let map = HashMap::new();
+}
+```
+
+
+[discrete]
+=== `change_return_type_to_result`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/change_return_type_to_result.rs#L8[change_return_type_to_result.rs]
+
+Change the function's return type to Result.
+
+.Before
+```rust
+fn foo() -> i32┃ { 42i32 }
+```
+
+.After
+```rust
+fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
+```
+
+
+[discrete]
+=== `change_visibility`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/change_visibility.rs#L14[change_visibility.rs]
+
+Adds or changes existing visibility specifier.
+
+.Before
+```rust
+┃fn frobnicate() {}
+```
+
+.After
+```rust
+pub(crate) fn frobnicate() {}
+```
+
+
+[discrete]
+=== `convert_to_guarded_return`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/early_return.rs#L21[early_return.rs]
+
+Replace a large conditional with a guarded return.
+
+.Before
+```rust
+fn main() {
+    ┃if cond {
+        foo();
+        bar();
+    }
+}
+```
+
+.After
+```rust
+fn main() {
+    if !cond {
+        return;
+    }
+    foo();
+    bar();
+}
+```
+
+
+[discrete]
+=== `fill_match_arms`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/fill_match_arms.rs#L14[fill_match_arms.rs]
+
+Adds missing clauses to a `match` expression.
+
+.Before
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        ┃
+    }
+}
+```
+
+.After
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        $0Action::Move { distance } => {}
+        Action::Stop => {}
+    }
+}
+```
+
+
+[discrete]
+=== `fix_visibility`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/fix_visibility.rs#L13[fix_visibility.rs]
+
+Makes inaccessible item public.
+
+.Before
+```rust
+mod m {
+    fn frobnicate() {}
+}
+fn main() {
+    m::frobnicate┃() {}
+}
+```
+
+.After
+```rust
+mod m {
+    $0pub(crate) fn frobnicate() {}
+}
+fn main() {
+    m::frobnicate() {}
+}
+```
+
+
+[discrete]
+=== `flip_binexpr`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/flip_binexpr.rs#L5[flip_binexpr.rs]
+
+Flips operands of a binary expression.
+
+.Before
+```rust
+fn main() {
+    let _ = 90 +┃ 2;
+}
+```
+
+.After
+```rust
+fn main() {
+    let _ = 2 + 90;
+}
+```
+
+
+[discrete]
+=== `flip_comma`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/flip_comma.rs#L5[flip_comma.rs]
+
+Flips two comma-separated items.
+
+.Before
+```rust
+fn main() {
+    ((1, 2),┃ (3, 4));
+}
+```
+
+.After
+```rust
+fn main() {
+    ((3, 4), (1, 2));
+}
+```
+
+
+[discrete]
+=== `flip_trait_bound`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/flip_trait_bound.rs#L9[flip_trait_bound.rs]
+
+Flips two trait bounds.
+
+.Before
+```rust
+fn foo<T: Clone +┃ Copy>() { }
+```
+
+.After
+```rust
+fn foo<T: Copy + Clone>() { }
+```
+
+
+[discrete]
+=== `inline_local_variable`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/inline_local_variable.rs#L13[inline_local_variable.rs]
+
+Inlines local variable.
+
+.Before
+```rust
+fn main() {
+    let x┃ = 1 + 2;
+    x * 4;
+}
+```
+
+.After
+```rust
+fn main() {
+    (1 + 2) * 4;
+}
+```
+
+
+[discrete]
+=== `introduce_named_lifetime`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/introduce_named_lifetime.rs#L12[introduce_named_lifetime.rs]
+
+Change an anonymous lifetime to a named lifetime.
+
+.Before
+```rust
+impl Cursor<'_┃> {
+    fn node(self) -> &SyntaxNode {
+        match self {
+            Cursor::Replace(node) | Cursor::Before(node) => node,
+        }
+    }
+}
+```
+
+.After
+```rust
+impl<'a> Cursor<'a> {
+    fn node(self) -> &SyntaxNode {
+        match self {
+            Cursor::Replace(node) | Cursor::Before(node) => node,
+        }
+    }
+}
+```
+
+
+[discrete]
+=== `introduce_variable`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/introduce_variable.rs#L14[introduce_variable.rs]
+
+Extracts subexpression into a variable.
+
+.Before
+```rust
+fn main() {
+    ┃(1 + 2)┃ * 4;
+}
+```
+
+.After
+```rust
+fn main() {
+    let $0var_name = (1 + 2);
+    var_name * 4;
+}
+```
+
+
+[discrete]
+=== `invert_if`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/invert_if.rs#L12[invert_if.rs]
+
+Apply invert_if
+This transforms if expressions of the form `if !x {A} else {B}` into `if x {B} else {A}`
+This also works with `!=`. This assist can only be applied with the cursor
+on `if`.
+
+.Before
+```rust
+fn main() {
+    if┃ !y { A } else { B }
+}
+```
+
+.After
+```rust
+fn main() {
+    if y { B } else { A }
+}
+```
+
+
+[discrete]
+=== `make_raw_string`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L10[raw_string.rs]
+
+Adds `r#` to a plain string literal.
+
+.Before
+```rust
+fn main() {
+    "Hello,┃ World!";
+}
+```
+
+.After
+```rust
+fn main() {
+    r#"Hello, World!"#;
+}
+```
+
+
+[discrete]
+=== `make_usual_string`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L39[raw_string.rs]
+
+Turns a raw string into a plain string.
+
+.Before
+```rust
+fn main() {
+    r#"Hello,┃ "World!""#;
+}
+```
+
+.After
+```rust
+fn main() {
+    "Hello, \"World!\"";
+}
+```
+
+
+[discrete]
+=== `merge_imports`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/merge_imports.rs#L14[merge_imports.rs]
+
+Merges two imports with a common prefix.
+
+.Before
+```rust
+use std::┃fmt::Formatter;
+use std::io;
+```
+
+.After
+```rust
+use std::{fmt::Formatter, io};
+```
+
+
+[discrete]
+=== `merge_match_arms`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/merge_match_arms.rs#L11[merge_match_arms.rs]
+
+Merges identical match arms.
+
+.Before
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        ┃Action::Move(..) => foo(),
+        Action::Stop => foo(),
+    }
+}
+```
+
+.After
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        Action::Move(..) | Action::Stop => foo(),
+    }
+}
+```
+
+
+[discrete]
+=== `move_arm_cond_to_match_guard`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/move_guard.rs#L56[move_guard.rs]
+
+Moves if expression from match arm body into a guard.
+
+.Before
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        Action::Move { distance } => ┃if distance > 10 { foo() },
+        _ => (),
+    }
+}
+```
+
+.After
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        Action::Move { distance } if distance > 10 => foo(),
+        _ => (),
+    }
+}
+```
+
+
+[discrete]
+=== `move_bounds_to_where_clause`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/move_bounds.rs#L10[move_bounds.rs]
+
+Moves inline type bounds to a where clause.
+
+.Before
+```rust
+fn apply<T, U, ┃F: FnOnce(T) -> U>(f: F, x: T) -> U {
+    f(x)
+}
+```
+
+.After
+```rust
+fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U {
+    f(x)
+}
+```
+
+
+[discrete]
+=== `move_guard_to_arm_body`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/move_guard.rs#L8[move_guard.rs]
+
+Moves match guard into match arm body.
+
+.Before
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        Action::Move { distance } ┃if distance > 10 => foo(),
+        _ => (),
+    }
+}
+```
+
+.After
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        Action::Move { distance } => if distance > 10 { foo() },
+        _ => (),
+    }
+}
+```
+
+
+[discrete]
+=== `remove_dbg`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/remove_dbg.rs#L8[remove_dbg.rs]
+
+Removes `dbg!()` macro call.
+
+.Before
+```rust
+fn main() {
+    ┃dbg!(92);
+}
+```
+
+.After
+```rust
+fn main() {
+    92;
+}
+```
+
+
+[discrete]
+=== `remove_hash`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L89[raw_string.rs]
+
+Removes a hash from a raw string literal.
+
+.Before
+```rust
+fn main() {
+    r#"Hello,┃ World!"#;
+}
+```
+
+.After
+```rust
+fn main() {
+    r"Hello, World!";
+}
+```
+
+
+[discrete]
+=== `remove_mut`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/remove_mut.rs#L5[remove_mut.rs]
+
+Removes the `mut` keyword.
+
+.Before
+```rust
+impl Walrus {
+    fn feed(&mut┃ self, amount: u32) {}
+}
+```
+
+.After
+```rust
+impl Walrus {
+    fn feed(&self, amount: u32) {}
+}
+```
+
+
+[discrete]
+=== `reorder_fields`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/reorder_fields.rs#L10[reorder_fields.rs]
+
+Reorder the fields of record literals and record patterns in the same order as in
+the definition.
+
+.Before
+```rust
+struct Foo {foo: i32, bar: i32};
+const test: Foo = ┃Foo {bar: 0, foo: 1}
+```
+
+.After
+```rust
+struct Foo {foo: i32, bar: i32};
+const test: Foo = Foo {foo: 1, bar: 0}
+```
+
+
+[discrete]
+=== `replace_if_let_with_match`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_if_let_with_match.rs#L13[replace_if_let_with_match.rs]
+
+Replaces `if let` with an else branch with a `match` expression.
+
+.Before
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    ┃if let Action::Move { distance } = action {
+        foo(distance)
+    } else {
+        bar()
+    }
+}
+```
+
+.After
+```rust
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+    match action {
+        Action::Move { distance } => foo(distance),
+        _ => bar(),
+    }
+}
+```
+
+
+[discrete]
+=== `replace_let_with_if_let`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_let_with_if_let.rs#L14[replace_let_with_if_let.rs]
+
+Replaces `let` with an `if-let`.
+
+.Before
+```rust
+
+fn main(action: Action) {
+    ┃let x = compute();
+}
+
+fn compute() -> Option<i32> { None }
+```
+
+.After
+```rust
+
+fn main(action: Action) {
+    if let Some(x) = compute() {
+    }
+}
+
+fn compute() -> Option<i32> { None }
+```
+
+
+[discrete]
+=== `replace_qualified_name_with_use`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs#L6[replace_qualified_name_with_use.rs]
+
+Adds a use statement for a given fully-qualified name.
+
+.Before
+```rust
+fn process(map: std::collections::┃HashMap<String, String>) {}
+```
+
+.After
+```rust
+use std::collections::HashMap;
+
+fn process(map: HashMap<String, String>) {}
+```
+
+
+[discrete]
+=== `replace_unwrap_with_match`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs#L17[replace_unwrap_with_match.rs]
+
+Replaces `unwrap` a `match` expression. Works for Result and Option.
+
+.Before
+```rust
+enum Result<T, E> { Ok(T), Err(E) }
+fn main() {
+    let x: Result<i32, i32> = Result::Ok(92);
+    let y = x.┃unwrap();
+}
+```
+
+.After
+```rust
+enum Result<T, E> { Ok(T), Err(E) }
+fn main() {
+    let x: Result<i32, i32> = Result::Ok(92);
+    let y = match x {
+        Ok(a) => a,
+        $0_ => unreachable!(),
+    };
+}
+```
+
+
+[discrete]
+=== `split_import`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/split_import.rs#L7[split_import.rs]
+
+Wraps the tail of import into braces.
+
+.Before
+```rust
+use std::┃collections::HashMap;
+```
+
+.After
+```rust
+use std::{collections::HashMap};
+```
+
+
+[discrete]
+=== `unwrap_block`
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/unwrap_block.rs#L9[unwrap_block.rs]
+
+This assist removes if...else, for, while and loop control statements to just keep the body.
+
+.Before
+```rust
+fn foo() {
+    if true {┃
+        println!("foo");
+    }
+}
+```
+
+.After
+```rust
+fn foo() {
+    println!("foo");
+}
+```
diff --git a/docs/user/generated_features.adoc b/docs/user/generated_features.adoc
new file mode 100644
index 000000000..12812fa0b
--- /dev/null
+++ b/docs/user/generated_features.adoc
@@ -0,0 +1,298 @@
+=== Expand Macro Recursively
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/expand_macro.rs#L15[expand_macro.rs]
+
+Shows the full macro expansion of the macro at current cursor.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Expand macro recursively**
+|===
+
+
+=== Extend Selection
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/extend_selection.rs#L15[extend_selection.rs]
+
+Extends the current selection to the encompassing syntactic construct
+(expression, statement, item, module, etc). It works with multiple cursors.
+
+|===
+| Editor  | Shortcut
+
+| VS Code | kbd:[Ctrl+Shift+→]
+|===
+
+
+=== File Structure
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/display/structure.rs#L17[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
+
+|===
+| Editor  | Shortcut
+
+| VS Code | kbd:[Ctrl+Shift+O]
+|===
+
+
+=== Go to Definition
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/goto_definition.rs#L18[goto_definition.rs]
+
+Navigates to the definition of an identifier.
+
+|===
+| Editor  | Shortcut
+
+| VS Code | kbd:[F12]
+|===
+
+
+=== Go to Implementation
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/goto_implementation.rs#L7[goto_implementation.rs]
+
+Navigates to the impl block of structs, enums or traits. Also implemented as a code lens.
+
+|===
+| Editor  | Shortcut
+
+| VS Code | kbd:[Ctrl+F12]
+|===
+
+
+=== Go to Type Definition
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/goto_type_definition.rs#L6[goto_type_definition.rs]
+
+Navigates to the type of an identifier.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Go to Type Definition*
+|===
+
+
+=== Hover
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/hover.rs#L63[hover.rs]
+
+Shows additional information, like type of an expression or documentation for definition when "focusing" code.
+Focusing is usually hovering with a mouse, but can also be triggered with a shortcut.
+
+
+=== Inlay Hints
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/inlay_hints.rs#L40[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 shows hits for
+
+* types of local variables
+* names of function arguments
+* types of chained expressions
+
+**Note:** VS Code does not have native support for inlay hints https://github.com/microsoft/vscode/issues/16221[yet] and the hints are implemented using decorations.
+This approach has limitations, the caret movement and bracket highlighting near the edges of the hint may be weird:
+https://github.com/rust-analyzer/rust-analyzer/issues/1623[1], https://github.com/rust-analyzer/rust-analyzer/issues/3453[2].
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Toggle inlay hints*
+|===
+
+
+=== Join Lines
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/join_lines.rs#L12[join_lines.rs]
+
+Join selected lines into one, smartly fixing up whitespace, trailing commas, and braces.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Join lines**
+|===
+
+
+=== Magic Completions
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/completion.rs#L38[completion.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.not` -> `!expr`
+- `expr.dbg` -> `dbg!(expr)`
+
+There also snippet completions:
+
+.Expressions
+- `pd` -> `println!("{:?}")`
+- `ppd` -> `println!("{:#?}")`
+
+.Items
+- `tfn` -> `#[test] fn f(){}`
+- `tmod` ->
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fn() {}
+}
+```
+
+
+=== Matching Brace
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/matching_brace.rs#L3[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.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Find matching brace**
+|===
+
+
+=== On Typing Assists
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/typing.rs#L35[typing.rs]
+
+Some features trigger on typing certain characters:
+
+- 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
+
+
+=== Parent Module
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/parent_module.rs#L12[parent_module.rs]
+
+Navigates to the parent module of the current module.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Locate parent module**
+|===
+
+
+=== Run
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/runnables.rs#L45[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!
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Run**
+|===
+
+
+=== Semantic Syntax Highlighting
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/syntax_highlighting.rs#L33[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 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.
+
+
+=== Show Syntax Tree
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/syntax_tree.rs#L9[syntax_tree.rs]
+
+Shows the parse tree of the current file. It exists mostly for debugging
+rust-analyzer itself.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Show Syntax Tree**
+|===
+
+
+=== Status
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/status.rs#L27[status.rs]
+
+Shows internal statistic about memory usage of rust-analyzer.
+
+|===
+| Editor  | Action Name
+
+| VS Code | **Rust Analyzer: Status**
+|===
+
+
+=== Structural Seach and Replace
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide/src/ssr.rs#L26[ssr.rs]
+
+Search and replace with named wildcards that will match any expression.
+The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
+A `$<name>:expr` placeholder in the search pattern will match any expression and `$<name>` will reference it in the replacement.
+Available via the command `rust-analyzer.ssr`.
+
+```rust
+// Using structural search replace command [foo($a:expr, $b:expr) ==>> ($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**
+|===
+
+
+=== Workspace Symbol
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_ide_db/src/symbol_index.rs#L113[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.
+
+|===
+| Editor  | Shortcut
+
+| VS Code | kbd:[Ctrl+T]
+|===
diff --git a/docs/user/readme.adoc b/docs/user/manual.adoc
index 4cb1e23e8..202783fd9 100644
--- a/docs/user/readme.adoc
+++ b/docs/user/manual.adoc
@@ -2,14 +2,9 @@
 :toc: preamble
 :sectanchors:
 :page-layout: post
-// https://gist.github.com/dcode/0cfbf2699a1fe9b46ff04c41721dda74#admonitions
-:tip-caption: :bulb:
-:note-caption: :information_source:
-:important-caption: :heavy_exclamation_mark:
-:caution-caption: :fire:
-:warning-caption: :warning:
-
-
+:icons: font
+:source-highlighter: rouge
+:experimental:
 
 // Master copy of this document lives in the https://github.com/rust-analyzer/rust-analyzer repository
 
@@ -19,7 +14,9 @@ https://microsoft.github.io/language-server-protocol/[Language Server Protocol]
 The LSP allows various code editors, like VS Code, Emacs or Vim, to implement semantic features like completion or goto definition by talking to an external language server process.
 
 To improve this document, send a pull request against
-https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/readme.adoc[this file].
+https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/manual.adoc[this file].
+
+If you have questions about using rust-analyzer, please ask them in the https://users.rust-lang.org/c/ide/14["`IDEs and Editors`"] topic of Rust users forum.
 
 == Installation
 
@@ -57,9 +54,13 @@ To disable this notification put the following to `settings.json`
 ----
 ====
 
-The server binary is stored in `~/.config/Code/User/globalStorage/matklad.rust-analyzer` (Linux) or in `~/.Library/Application Support/Code/User/globalStorage/matklad.rust-analyzer` (macOS) or in `%APPDATA%\Code\User\globalStorage` (Windows).
+The server binary is stored in:
 
-Note that we only support the latest version of VS Code.
+* Linux: `~/.config/Code/User/globalStorage/matklad.rust-analyzer`
+* macOS: `~/Library/Application Support/Code/User/globalStorage/matklad.rust-analyzer`
+* Windows: `%APPDATA%\Code\User\globalStorage\matklad.rust-analyzer`
+
+Note that we only support two most recent versions of VS Code.
 
 ==== Updates
 
@@ -104,14 +105,27 @@ Here are some useful self-diagnostic commands:
 
 * **Rust Analyzer: Show RA Version** shows the version of `rust-analyzer` binary
 * **Rust Analyzer: Status** prints some statistics about the server, like the few latest LSP requests
-* To enable server-side logging, run with `env RUST_LOG=info` and see `Output > Rust Analyzer Language Server` in VS Code's panel.
+* To enable server-side logging, run with `env RA_LOG=info` and see `Output > Rust Analyzer Language Server` in VS Code's panel.
 * To log all LSP requests, add `"rust-analyzer.trace.server": "verbose"` to the settings and look for `Server Trace` in the panel.
 * To enable client-side logging, add `"rust-analyzer.trace.extension": true` to the settings and open the `Console` tab of VS Code developer tools.
 
+==== Special `when` clause context for keybindings.
+You may use `inRustProject` context to configure keybindings for rust projects only. For example:
+[source,json]
+----
+{
+  "key": "ctrl+i",
+  "command": "rust-analyzer.toggleInlayHints",
+  "when": "inRustProject"
+}
+----
+More about `when` clause contexts https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts[here].
+
 === rust-analyzer Language Server Binary
 
 Other editors generally require the `rust-analyzer` binary to be in `$PATH`.
-You can download the pre-built binary from the https://github.com/rust-analyzer/rust-analyzer/releases[releases] page. Typically, you then need to rename the binary for your platform, e.g. `rust-analyzer-mac` if you're on Mac OS, to `rust-analyzer` and make it executable in addition to moving it into a directory in your `$PATH`.
+You can download the pre-built binary from the https://github.com/rust-analyzer/rust-analyzer/releases[releases] page.
+Typically, you then need to rename the binary for your platform, e.g. `rust-analyzer-mac` if you're on Mac OS, to `rust-analyzer` and make it executable in addition to moving it into a directory in your `$PATH`.
 
 On Linux to install the `rust-analyzer` binary into `~/.local/bin`, this commands could be used
 
@@ -131,21 +145,21 @@ $ git clone https://github.com/rust-analyzer/rust-analyzer.git && cd rust-analyz
 $ cargo xtask install --server
 ----
 
-If your editor can't find the binary even though the binary is on your `$PATH`, the likely explanation is that it doesn't see the same `$PATH` as the shell, see https://github.com/rust-analyzer/rust-analyzer/issues/1811[this issue]. On Unix, running the editor from a shell or changing the `.desktop` file to set the environment should help.
+If your editor can't find the binary even though the binary is on your `$PATH`, the likely explanation is that it doesn't see the same `$PATH` as the shell, see https://github.com/rust-analyzer/rust-analyzer/issues/1811[this issue].
+On Unix, running the editor from a shell or changing the `.desktop` file to set the environment should help.
 
 ==== Arch Linux
 
-The `rust-analyzer` binary can be installed from AUR (Arch User Repository):
+The `rust-analyzer` binary can be installed from the repos or AUR (Arch User Repository):
 
-- https://aur.archlinux.org/packages/rust-analyzer-bin[`rust-analyzer-bin`] (binary from GitHub releases)
-- https://aur.archlinux.org/packages/rust-analyzer[`rust-analyzer`] (built from latest tagged source)
-- https://aur.archlinux.org/packages/rust-analyzer-git[`rust-analyzer-git`] (latest git version)
+- https://www.archlinux.org/packages/community/x86_64/rust-analyzer/[`rust-analyzer`] (built from latest tagged source)
+- https://aur.archlinux.org/packages/rust-analyzer-git[`rust-analyzer-git`] (latest Git version)
 
-Install it with AUR helper of your choice, for example:
+Install it with pacman, for example:
 
 [source,bash]
 ----
-$ yay -S rust-analyzer-bin
+$ pacman -S rust-analyzer
 ----
 
 === Emacs
@@ -159,11 +173,11 @@ Emacs support is maintained as part of the https://github.com/emacs-lsp/lsp-mode
 3. Run `lsp` in a Rust buffer.
 4. (Optionally) bind commands like `lsp-rust-analyzer-join-lines`, `lsp-extend-selection` and `lsp-rust-analyzer-expand-macro` to keys.
 
-=== Vim
+=== Vim/NeoVim
 
-Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
+Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>. Not needed if the extension can install/update it on its own, coc-rust-analyzer is one example.
 
-The are several LSP client implementations for vim:
+The are several LSP client implementations for vim or neovim:
 
 ==== coc-rust-analyzer
 
@@ -183,7 +197,7 @@ The are several LSP client implementations for vim:
 
 1. Install LanguageClient-neovim by following the instructions
    https://github.com/autozimu/LanguageClient-neovim[here]
-   * The github project wiki has extra tips on configuration
+   * The GitHub project wiki has extra tips on configuration
 
 2. Configure by adding this to your vim/neovim config file (replacing the existing Rust-specific line if it exists):
 +
@@ -201,7 +215,7 @@ let g:LanguageClient_serverCommands = {
 
 2. Configure by adding this to your vim/neovim config file (replacing the existing Rust-specific line if it exists):
 +
-[source,vim]   
+[source,vim]
 ----
 let g:ycm_language_server =
 \ [
@@ -216,17 +230,11 @@ let g:ycm_language_server =
 
 ==== ALE
 
-To add the LSP server to https://github.com/dense-analysis/ale[ale]:
+To use the LSP server in https://github.com/dense-analysis/ale[ale]:
 
 [source,vim]
 ----
-call ale#linter#Define('rust', {
-\   'name': 'rust-analyzer',
-\   'lsp': 'stdio',
-\   'executable': 'rust-analyzer',
-\   'command': '%e',
-\   'project_root': '.',
-\})
+let g:ale_linters = {'rust': ['analyzer']}
 ----
 
 ==== nvim-lsp
@@ -252,6 +260,23 @@ If it worked, you should see "rust-analyzer, Line X, Column Y" on the left side
 
 If you get an error saying `No such file or directory: 'rust-analyzer'`, see the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>> section on installing the language server binary.
 
-== Usage
+=== GNOME Builder
+
+Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
+
+Gnome Builder currently has support for RLS, and there's no way to configure the language server executable. A future version might support `rust-analyzer` out of the box.
+
+1. Rename, symlink or copy the `rust-analyzer` binary to `rls` and place it somewhere Builder can find (in `PATH`, or under `~/.cargo/bin`).
+2. Enable the Rust Builder plugin.
+
+== Features
+
+include::./generated_features.adoc[]
+
+== Assists (Code Actions)
+
+Assists, or code actions, are small local refactorings, available in a particular context.
+They are usually triggered by a shortcut or by clicking a light bulb icon in the editor.
+Cursor position or selection is signified by `┃` character.
 
-See https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/features.md[features.md].
+include::./generated_assists.adoc[]