4 files changed, 528 insertions, 422 deletions

diff --git a/docs/dev/README.md b/docs/dev/README.md
index e5a7ea5f6..006518afc 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -14,7 +14,7 @@ To learn more about how rust-analyzer works, see
 
 We also publish rustdoc docs to pages:
 
-https://rust-analyzer.github.io/rust-analyzer/api-docs/ra_ide_api/
+https://rust-analyzer.github.io/rust-analyzer/ra_ide_api/
 
 Various organizational and process issues are discussed in this document.
 
diff --git a/docs/user/README.md b/docs/user/README.md
index f1628d6a4..eb1d5ed14 100644
--- a/docs/user/README.md
+++ b/docs/user/README.md
@@ -83,8 +83,6 @@ host.
 ### Settings
 
 * `rust-analyzer.highlightingOn`: enables experimental syntax highlighting
-* `rust-analyzer.showWorkspaceLoadedNotification`: to ease troubleshooting, a
-  notification is shown by default when a workspace is loaded
 * `rust-analyzer.enableEnhancedTyping`: by default, rust-analyzer intercepts
   `Enter` key to make it easier to continue comments. Note that it may conflict with VIM emulation plugin.
 * `rust-analyzer.raLspServerPath`: path to `ra_lsp_server` executable
@@ -102,6 +100,17 @@ host.
 * `rust-analyzer.trace.server`: enables internal logging
 * `rust-analyzer.trace.cargo-watch`: enables cargo-watch logging
 * `RUST_SRC_PATH`: environment variable that overwrites the sysroot
+* `rust-analyzer.featureFlags` -- a JSON object to tweak fine-grained behavior:
+   ```js
+   {
+       // Show diagnostics produced by rust-analyzer itself.
+       "lsp.diagnostics": true,
+       // Automatically insert `()` and `<>` when completing functions and types.
+       "completion.insertion.add-call-parenthesis": true,
+       // Show notification when workspace is fully loaded
+       "notifications.workspace-loaded": true,
+   }
+   ```
 
 
 ## Emacs
@@ -173,7 +182,11 @@ Installation:
     "syntaxes": [
         "Packages/Rust/Rust.sublime-syntax",
         "Packages/Rust Enhanced/RustEnhanced.sublime-syntax"
-    ]
+    ],
+    "initializationOptions": {
+      "featureFlags": {
+      }
+    },
 }
 ```
 
diff --git a/docs/user/assists.md b/docs/user/assists.md
new file mode 100644
index 000000000..303353e74
--- /dev/null
+++ b/docs/user/assists.md
@@ -0,0 +1,505 @@
+# Assists
+
+Cursor position or selection is signified by `┃` character.
+
+
+## `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_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 T {
+    Type X;
+    fn foo(&self);
+    fn bar(&self) {}
+}
+
+impl T for () {
+    Type X = ();
+    fn foo(&self) {}┃
+
+}
+
+// AFTER
+trait T {
+    Type X;
+    fn foo(&self);
+    fn bar(&self) {}
+}
+
+impl T for () {
+    Type X = ();
+    fn foo(&self) {}
+    fn bar(&self) {}
+
+}
+```
+
+## `add_impl_missing_members`
+
+Adds scaffold for required impl members.
+
+```rust
+// BEFORE
+trait T {
+    Type X;
+    fn foo(&self);
+    fn bar(&self) {}
+}
+
+impl T for () {┃
+
+}
+
+// AFTER
+trait T {
+    Type X;
+    fn foo(&self);
+    fn bar(&self) {}
+}
+
+impl T for () {
+    fn foo(&self) { unimplemented!() }
+
+}
+```
+
+## `add_import`
+
+Adds a use statement for a given fully-qualified path.
+
+```rust
+// BEFORE
+fn process(map: std::collections::┃HashMap<String, String>) {}
+
+// AFTER
+use std::collections::HashMap;
+
+fn process(map: HashMap<String, String>) {}
+```
+
+## `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) {}
+}
+```
+
+## `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;
+}
+```
+
+## `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_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!";
+}
+```
+
+## `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(),
+    }
+}
+```
+
+## `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
index 8b7a8d7fc..c160dd70b 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -97,424 +97,12 @@ Start `cargo watch` for live error highlighting. Will prompt to install if it's
 
 Stop `cargo watch`
 
-### 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]`
-
-```rust
-// before:
-struct Foo {
-    <|>x: i32
-}
-// after:
-#[derive(<|>)]
-struct Foo {
-    x: i32
-}
-```
-
-- Add `impl`
-
-```rust
-// before:
-struct Foo<'a, T: Debug> {
-    <|>t: T
-}
-// after:
-struct Foo<'a, T: Debug> {
-    t: T
-}
-
-impl<'a, T: Debug> Foo<'a, T> {
-    <|>
-}
-```
-
-- Add missing `impl` members
-
-```rust
-// before:
-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);
-}
-
-struct S;
-
-impl Foo for S {
-    fn bar(&self) {}
-    fn foo(&self) { unimplemented!() }
-    fn baz(&self) { unimplemented!() }<|>
-}
-```
-
-- Apply [De Morgan's law](https://en.wikipedia.org/wiki/De_Morgan%27s_laws)
-
-```rust
-// before:
-fn example(x: bool) -> bool {
-    !x || !x
-}
-
-// after:
-fn example(x: bool) -> bool {
-    !(x && x)
-}
-```
-
-- 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:
-
-```rust
-// before:
-fn foo() {
-    foo(<|>1 + 1<|>);
-}
-
-// after:
-fn foo() {
-    let var_name = 1 + 1;
-    foo(var_name);
-}
-```
-
-- Inline local variable:
-
-```rust
-// before:
-fn foo() {
-    let a<|> = 1 + 1;
-    let b = a * 10;
-}
-
-// after:
-fn foo() {
-    let b = (1 + 1) * 10;
-}
-```
-
-- 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
-// before:
-impl VariantData {
-    pub fn is_struct(&self) -> bool {
-        if <|>let VariantData::Struct(..) = *self {
-            true
-        } else {
-            false
-        }
-    }
-}
-
-// after:
-impl VariantData {
-    pub fn is_struct(&self) -> bool {
-        <|>match *self {
-            VariantData::Struct(..) => true,
-            _ => false,
-        }
-    }
-}
-```
-
-- Split import
-
-```rust
-// before:
-use crate:<|>:db::{RootDatabase, FileSymbol};
-// after:
-use crate::{<|>db::{RootDatabase, FileSymbol}};
-```
-
-- Flip binary expression
-
-```rust
-// before:
-fn foo() {
-    if 1 <<|> 2 {
-        println!("Who would have thought?");
-    }
-}
-// after:
-fn foo() {
-    if 2 ><|> 1 {
-        println!("Who would have thought?");
-    }
-}
-```
-
-- Add explicit type
-
-```rust
-// before:
-fn foo() {
-    let t<|> = (&2, Some(1));
-}
-// after:
-fn foo() {
-    let t<|>: (&i32, Option<i32>) = (&2, Some(1));
-}
-```
-
-- Move guard expression to match arm body
-```rust
-// before:
-fn f() {
-    match x {
-        <|>y @ 4 | y @ 5    if y > 5 => true,
-        _ => false
-    }
-}
-// after:
-fn f() {
-    match x {
-        y @ 4 | y @ 5 => if y > 5 { <|>true },
-        _ => false
-    }
-}
-```
-
-- Move if condition to match arm guard
-```rust
-// before:
-fn f() {
-    let mut t = 'a';
-    let chars = "abcd";
-    match t {
-        '\r' => if chars.clone().next().is_some() {
-            t = 'e';<|>
-            false
-        },
-        _ => true
-    }
-}
-
-// after:
-fn f() {
-    let mut t = 'a';
-    let chars = "abcd";
-    match t {
-        '\r' <|>if chars.clone().next().is_some() => {
-            t = 'e';
-            false
-        },
-        _ => true
-    }
-}
-```
-
-- Move type bounds to where clause
-
-```rust
-// before:
-fn foo<T: u32, F: FnOnce(T) -> T>() {}
-
-// after:
-fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
-```
-
-- Make raw string unescaped
-
-```rust
-// before:
-fn f() {
-    let s = <|>"ab\ncd";
-}
-
-// after:
-fn f() {
-    let s = <|>r#"ab
-cd"#;
-}
-```
-
-- Make usual string
-
-```rust
-// before:
-fn f() {
-    let s = <|>r#"abcd"#;
-}
-
-// after:
-fn f() {
-    let s = <|>"abcd";
-}
-```
-
-- Add hash
-
-```rust
-// before:
-fn f() {
-    let s = <|>r"abcd";
-}
-
-// after:
-fn f() {
-    let s = <|>r#"abcd"#;
-}
-```
-
-- Remove hash
-
-```rust
-// before:
-fn f() {
-    let s = <|>r#"abcd"#;
-}
-
-// after:
-fn f() {
-    let s = <|>r"abcd";
-}
-```
+### 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