rust-analyzer/docs/user/generated_assists.adoc

[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");
}
```