Assists (Code Actions) - rust-analyzer

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Assists

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.

### `add_braces`

Source: add_braces.rs

Adds braces to closure bodies, match arm expressions and assignment bodies.

#### Before

    fn foo(n: i32) -> i32 {
        match n {
            1 =>┃ n + 1,
            _ => 0
        }
    }

#### After

    fn foo(n: i32) -> i32 {
        match n {
            1 => {
                n + 1
            },
            _ => 0
        }
    }

#### Before

    fn foo(n: i32) -> i32 {
        let x =┃ n + 2;
    }

#### After

    fn foo(n: i32) -> i32 {
        let x = {
            n + 2
        };
    }

### `add_explicit_enum_discriminant`

Source: add_explicit_enum_discriminant.rs

Adds explicit discriminant to all enum variants.

#### Before

    enum TheEnum┃ {
        Foo,
        Bar,
        Baz = 42,
        Quux,
    }

#### After

    enum TheEnum {
        Foo = 0,
        Bar = 1,
        Baz = 42,
        Quux = 43,
    }

### `add_explicit_method_call_deref`

Source: add_explicit_dot_deref.rs

Insert explicit method call reference and dereferences.

#### Before

    struct Foo;
    impl Foo { fn foo(&self) {} }
    fn test() {
        Foo┃.┃foo();
    }

#### After

    struct Foo;
    impl Foo { fn foo(&self) {} }
    fn test() {
        (&Foo).foo();
    }

### `add_explicit_type`

Source: add_explicit_type.rs

Specify type for a let binding.

#### Before

    fn main() {
        let x┃ = 92;
    }

#### After

    fn main() {
        let x: i32 = 92;
    }

### `add_hash`

Source: raw_string.rs

Adds a hash to a raw string literal.

#### Before

    fn main() {
        r#"Hello,┃ World!"#;
    }

#### After

    fn main() {
        r##"Hello, World!"##;
    }

### `add_impl_default_members`

Source: add_missing_impl_members.rs

Adds scaffold for overriding default impl members.

#### 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`

Source: add_missing_impl_members.rs

Adds scaffold for required impl members.

#### 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 () {
        ┃type X;

        fn foo(&self) -> u32 {
            todo!()
        }
    }

### `add_label_to_loop`

Source: add_label_to_loop.rs

Adds a label to a loop.

#### Before

    fn main() {
        loop┃ {
            break;
            continue;
        }
    }

#### After

    fn main() {
        ${1:'l}: loop {
            break ${2:'l};
            continue ${0:'l};
        }
    }

### `add_lifetime_to_type`

Source: add_lifetime_to_type.rs

Adds a new lifetime to a struct, enum or union.

#### Before

    struct Point {
        x: &┃u32,
        y: u32,
    }

#### After

    struct Point<'a> {
        x: &'a u32,
        y: u32,
    }

### `add_missing_match_arms`

Source: add_missing_match_arms.rs

Adds missing clauses to a `match` expression.

#### 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 } => ${1:todo!()},
            Action::Stop => ${2:todo!()},┃
        }
    }

### `add_return_type`

Source: add_return_type.rs

Adds the return type to a function or closure inferred from its tail expression if it doesn’t have a return type specified. This assists is useable in a functions or closures tail expression or return type position.

#### Before

    fn foo() { 4┃2i32 }

#### After

    fn foo() -> i32 { 42i32 }

### `add_turbo_fish`

Source: add_turbo_fish.rs

Adds `::<_>` to a call of a generic method or function.

#### Before

    fn make<T>() -> T { todo!() }
    fn main() {
        let x = make┃();
    }

#### After

    fn make<T>() -> T { todo!() }
    fn main() {
        let x = make::<${0:_}>();
    }

### `apply_demorgan`

Source: apply_demorgan.rs

Apply De Morgan’s law. 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 `&&`.

#### Before

    fn main() {
        if x != 4 ||┃ y < 3.14 {}
    }

#### After

    fn main() {
        if !(x == 4 && y >= 3.14) {}
    }

### `apply_demorgan_iterator`

Source: apply_demorgan.rs

Apply De Morgan’s law to `Iterator::all` and `Iterator::any`.

This transforms expressions of the form `!iter.any(|x| predicate(x))` into `iter.all(|x| !predicate(x))` and vice versa. This also works the other way for `Iterator::all` into `Iterator::any`.

#### Before

    fn main() {
        let arr = [1, 2, 3];
        if !arr.into_iter().┃any(|num| num == 4) {
            println!("foo");
        }
    }

#### After

    fn main() {
        let arr = [1, 2, 3];
        if arr.into_iter().all(|num| num != 4) {
            println!("foo");
        }
    }

### `auto_import`

Source: auto_import.rs

If the name is unresolved, provides all possible imports for it.

#### Before

    fn main() {
        let map = HashMap┃::new();
    }

#### After

    use std::collections::HashMap;

    fn main() {
        let map = HashMap::new();
    }

### `bind_unused_param`

Source: bind_unused_param.rs

Binds unused function parameter to an underscore.

#### Before

    fn some_function(x: i32┃) {}

#### After

    fn some_function(x: i32) {
        let _ = x;
    }

### `change_visibility`

Source: change_visibility.rs

Adds or changes existing visibility specifier.

#### Before

    ┃fn frobnicate() {}

#### After

    pub(crate) fn frobnicate() {}

### `comment_to_doc`

Source: convert_comment_from_or_to_doc.rs

Converts comments to documentation.

#### Before

    // Wow what ┃a nice module
    // I sure hope this shows up when I hover over it

#### After

    //! Wow what a nice module
    //! I sure hope this shows up when I hover over it

### `convert_bool_then_to_if`

Source: convert_bool_then.rs

Converts a `bool::then` method call to an equivalent if expression.

#### Before

    fn main() {
        (0 == 0).then┃(|| val)
    }

#### After

    fn main() {
        if 0 == 0 {
            Some(val)
        } else {
            None
        }
    }

### `convert_bool_to_enum`

Source: convert_bool_to_enum.rs

This converts boolean local variables, fields, constants, and statics into a new enum with two variants `Bool::True` and `Bool::False`, as well as replacing all assignments with the variants and replacing all usages with `== Bool::True` or `== Bool::False`.

#### Before

    fn main() {
        let ┃bool = true;

        if bool {
            println!("foo");
        }
    }

#### After

    #[derive(PartialEq, Eq)]
    enum Bool { True, False }

    fn main() {
        let bool = Bool::True;

        if bool == Bool::True {
            println!("foo");
        }
    }

### `convert_char_literal`

Source: convert_char_literal.rs

Converts character literals between different representations. Currently supports normal character -> ASCII / Unicode escape.

#### Before

    const _: char = 'a'┃;

#### After

    const _: char = '\x61';

### `convert_closure_to_fn`

Source: convert_closure_to_fn.rs

This converts a closure to a freestanding function, changing all captures to parameters.

#### Before

    fn main() {
        let mut s = String::new();
        let closure = |┃a| s.push_str(a);
        closure("abc");
    }

#### After

    fn main() {
        let mut s = String::new();
        fn closure(a: &str, s: &mut String) {
            s.push_str(a)
        }
        closure("abc", &mut s);
    }

### `convert_for_loop_to_while_let`

Source: convert_for_to_while_let.rs

Converts a for loop into a while let on the Iterator.

#### Before

    fn main() {
        let x = vec![1, 2, 3];
        for┃ v in x {
            let y = v * 2;
        };
    }

#### After

    fn main() {
        let x = vec![1, 2, 3];
        let mut tmp = x.into_iter();
        while let Some(v) = tmp.next() {
            let y = v * 2;
        };
    }

### `convert_for_loop_with_for_each`

Source: convert_iter_for_each_to_for.rs

Converts a for loop into a for_each loop on the Iterator.

#### Before

    fn main() {
        let x = vec![1, 2, 3];
        for┃ v in x {
            let y = v * 2;
        }
    }

#### After

    fn main() {
        let x = vec![1, 2, 3];
        x.into_iter().for_each(|v| {
            let y = v * 2;
        });
    }

### `convert_from_to_tryfrom`

Source: convert_from_to_tryfrom.rs

Converts a From impl to a TryFrom impl, wrapping returns in `Ok`.

#### Before

    impl ┃From<usize> for Thing {
        fn from(val: usize) -> Self {
            Thing {
                b: val.to_string(),
                a: val
            }
        }
    }

#### After

    impl TryFrom<usize> for Thing {
        type Error = ${0:()};

        fn try_from(val: usize) -> Result<Self, Self::Error> {
            Ok(Thing {
                b: val.to_string(),
                a: val
            })
        }
    }

### `convert_if_to_bool_then`

Source: convert_bool_then.rs

Converts an if expression into a corresponding `bool::then` call.

#### Before

    fn main() {
        if┃ cond {
            Some(val)
        } else {
            None
        }
    }

#### After

    fn main() {
        cond.then(|| val)
    }

### `convert_integer_literal`

Source: convert_integer_literal.rs

Converts the base of integer literals to other bases.

#### Before

    const _: i32 = 10┃;

#### After

    const _: i32 = 0b1010;

### `convert_into_to_from`

Source: convert_into_to_from.rs

Converts an Into impl to an equivalent From impl.

#### Before

    impl ┃Into<Thing> for usize {
        fn into(self) -> Thing {
            Thing {
                b: self.to_string(),
                a: self
            }
        }
    }

#### After

    impl From<usize> for Thing {
        fn from(val: usize) -> Self {
            Thing {
                b: val.to_string(),
                a: val
            }
        }
    }

### `convert_iter_for_each_to_for`

Source: convert_iter_for_each_to_for.rs

Converts an Iterator::for_each function into a for loop.

#### Before

    fn main() {
        let iter = iter::repeat((9, 2));
        iter.for_each┃(|(x, y)| {
            println!("x: {}, y: {}", x, y);
        });
    }

#### After

    fn main() {
        let iter = iter::repeat((9, 2));
        for (x, y) in iter {
            println!("x: {}, y: {}", x, y);
        }
    }

### `convert_let_else_to_match`

Source: convert_let_else_to_match.rs

Converts let-else statement to let statement and match expression.

#### Before

    fn main() {
        let Ok(mut x) = f() else┃ { return };
    }

#### After

    fn main() {
        let mut x = match f() {
            Ok(x) => x,
            _ => return,
        };
    }

### `convert_match_to_let_else`

Source: convert_match_to_let_else.rs

Converts let statement with match initializer to let-else statement.

#### Before

    fn foo(opt: Option<()>) {
        let val┃ = match opt {
            Some(it) => it,
            None => return,
        };
    }

#### After

    fn foo(opt: Option<()>) {
        let Some(val) = opt else { return };
    }

### `convert_named_struct_to_tuple_struct`

Source: convert_named_struct_to_tuple_struct.rs

Converts struct with named fields to tuple struct, and analogously for enum variants with named fields.

#### Before

    struct Point┃ { x: f32, y: f32 }

    impl Point {
        pub fn new(x: f32, y: f32) -> Self {
            Point { x, y }
        }

        pub fn x(&self) -> f32 {
            self.x
        }

        pub fn y(&self) -> f32 {
            self.y
        }
    }

#### After

    struct Point(f32, f32);

    impl Point {
        pub fn new(x: f32, y: f32) -> Self {
            Point(x, y)
        }

        pub fn x(&self) -> f32 {
            self.0
        }

        pub fn y(&self) -> f32 {
            self.1
        }
    }

### `convert_nested_function_to_closure`

Source: convert_nested_function_to_closure.rs

Converts a function that is defined within the body of another function into a closure.

#### Before

    fn main() {
        fn fo┃o(label: &str, number: u64) {
            println!("{}: {}", label, number);
        }

        foo("Bar", 100);
    }

#### After

    fn main() {
        let foo = |label: &str, number: u64| {
            println!("{}: {}", label, number);
        };

        foo("Bar", 100);
    }

### `convert_range_for_to_while`

Source: convert_range_for_to_while.rs

Convert for each range into while loop.

#### Before

    fn foo() {
        ┃for i in 3..7 {
            foo(i);
        }
    }

#### After

    fn foo() {
        let mut i = 3;
        while i < 7 {
            foo(i);
            i += 1;
        }
    }

### `convert_to_guarded_return`

Source: convert_to_guarded_return.rs

Replace a large conditional with a guarded return.

#### Before

    fn main() {
        ┃if cond {
            foo();
            bar();
        }
    }

#### After

    fn main() {
        if !cond {
            return;
        }
        foo();
        bar();
    }

#### Before

    //- minicore: option
    fn foo() -> Option<i32> { None }
    fn main() {
        ┃let x = foo();
    }

#### After

    fn foo() -> Option<i32> { None }
    fn main() {
        let Some(x) = foo() else { return };
    }

### `convert_tuple_return_type_to_struct`

Source: convert_tuple_return_type_to_struct.rs

This converts the return type of a function from a tuple type into a tuple struct and updates the body accordingly.

#### Before

    fn bar() {
        let (a, b, c) = foo();
    }

    fn foo() -> (┃u32, u32, u32) {
        (1, 2, 3)
    }

#### After

    fn bar() {
        let FooResult(a, b, c) = foo();
    }

    struct FooResult(u32, u32, u32);

    fn foo() -> FooResult {
        FooResult(1, 2, 3)
    }

### `convert_tuple_struct_to_named_struct`

Source: convert_tuple_struct_to_named_struct.rs

Converts tuple struct to struct with named fields, and analogously for tuple enum variants.

#### Before

    struct Point┃(f32, f32);

    impl Point {
        pub fn new(x: f32, y: f32) -> Self {
            Point(x, y)
        }

        pub fn x(&self) -> f32 {
            self.0
        }

        pub fn y(&self) -> f32 {
            self.1
        }
    }

#### After

    struct Point { field1: f32, field2: f32 }

    impl Point {
        pub fn new(x: f32, y: f32) -> Self {
            Point { field1: x, field2: y }
        }

        pub fn x(&self) -> f32 {
            self.field1
        }

        pub fn y(&self) -> f32 {
            self.field2
        }
    }

### `convert_two_arm_bool_match_to_matches_macro`

Source: convert_two_arm_bool_match_to_matches_macro.rs

Convert 2-arm match that evaluates to a boolean into the equivalent matches! invocation.

#### Before

    fn main() {
        match scrutinee┃ {
            Some(val) if val.cond() => true,
            _ => false,
        }
    }

#### After

    fn main() {
        matches!(scrutinee, Some(val) if val.cond())
    }

### `convert_while_to_loop`

Source: convert_while_to_loop.rs

Replace a while with a loop.

#### Before

    fn main() {
        ┃while cond {
            foo();
        }
    }

#### After

    fn main() {
        loop {
            if !cond {
                break;
            }
            foo();
        }
    }

### `destructure_struct_binding`

Source: destructure_struct_binding.rs

Destructures a struct binding in place.

#### Before

    struct Foo {
        bar: i32,
        baz: i32,
    }
    fn main() {
        let ┃foo = Foo { bar: 1, baz: 2 };
        let bar2 = foo.bar;
        let baz2 = &foo.baz;
    }

#### After

    struct Foo {
        bar: i32,
        baz: i32,
    }
    fn main() {
        let Foo { bar, baz } = Foo { bar: 1, baz: 2 };
        let bar2 = bar;
        let baz2 = &baz;
    }

### `destructure_tuple_binding`

Source: destructure_tuple_binding.rs

Destructures a tuple binding in place.

#### Before

    fn main() {
        let ┃t = (1,2);
        let v = t.0;
    }

#### After

    fn main() {
        let (┃_0, _1) = (1,2);
        let v = _0;
    }

### `desugar_async_into_impl_future`

Source: toggle_async_sugar.rs

Rewrites asynchronous function from `async fn` into `-> impl Future`. This action does not touch the function body and therefore `0` block does not transform to `async { 0 }`.

#### Before

    pub as┃ync fn foo() -> usize {
        0
    }

#### After

    pub fn foo() -> impl core::future::Future<Output = usize> {
        0
    }

### `desugar_doc_comment`

Source: desugar_doc_comment.rs

Desugars doc-comments to the attribute form.

#### Before

    /// Multi-line┃
    /// comment

#### After

    #[doc = r"Multi-line
    comment"]

### `desugar_try_expr_let_else`

Source: desugar_try_expr.rs

Replaces a `try` expression with a `let else` statement.

#### Before

    fn handle() {
        let pat = Some(true)┃?;
    }

#### After

    fn handle() {
        let Some(pat) = Some(true) else {
            return None;
        };
    }

### `desugar_try_expr_match`

Source: desugar_try_expr.rs

Replaces a `try` expression with a `match` expression.

#### Before

    fn handle() {
        let pat = Some(true)┃?;
    }

#### After

    fn handle() {
        let pat = match Some(true) {
            Some(it) => it,
            None => return None,
        };
    }

### `expand_glob_import`

Source: expand_glob_import.rs

Expands glob imports.

#### Before

    mod foo {
        pub struct Bar;
        pub struct Baz;
    }

    use foo::*┃;

    fn qux(bar: Bar, baz: Baz) {}

#### After

    mod foo {
        pub struct Bar;
        pub struct Baz;
    }

    use foo::{Bar, Baz};

    fn qux(bar: Bar, baz: Baz) {}

### `expand_glob_reexport`

Source: expand_glob_import.rs

Expands non-private glob imports.

#### Before

    mod foo {
        pub struct Bar;
        pub struct Baz;
    }

    pub use foo::*┃;

#### After

    mod foo {
        pub struct Bar;
        pub struct Baz;
    }

    pub use foo::{Bar, Baz};

### `expand_record_rest_pattern`

Source: expand_rest_pattern.rs

Fills fields by replacing rest pattern in record patterns.

#### Before

    struct Bar { y: Y, z: Z }

    fn foo(bar: Bar) {
        let Bar { ..┃ } = bar;
    }

#### After

    struct Bar { y: Y, z: Z }

    fn foo(bar: Bar) {
        let Bar { y, z } = bar;
    }

### `expand_slice_rest_pattern`

Source: expand_rest_pattern.rs

Fills fields by replacing rest pattern in slice patterns.

#### Before

    fn foo(bar: [i32; 3]) {
        let [first, ..┃] = bar;
    }

#### After

    fn foo(bar: [i32; 3]) {
        let [first, _1, _2] = bar;
    }

### `expand_tuple_rest_pattern`

Source: expand_rest_pattern.rs

Fills fields by replacing rest pattern in tuple patterns.

#### Before

    fn foo(bar: (char, i32, i32)) {
        let (ch, ..┃) = bar;
    }

#### After

    fn foo(bar: (char, i32, i32)) {
        let (ch, _1, _2) = bar;
    }

### `expand_tuple_struct_rest_pattern`

Source: expand_rest_pattern.rs

Fills fields by replacing rest pattern in tuple struct patterns.

#### Before

    struct Bar(Y, Z);

    fn foo(bar: Bar) {
        let Bar(..┃) = bar;
    }

#### After

    struct Bar(Y, Z);

    fn foo(bar: Bar) {
        let Bar(_0, _1) = bar;
    }

### `extract_constant`

Source: extract_variable.rs

Extracts subexpression into a constant.

#### Before

    fn main() {
        ┃(1 + 2)┃ * 4;
    }

#### After

    fn main() {
        const ┃VAR_NAME: i32 = 1 + 2;
        VAR_NAME * 4;
    }

### `extract_expressions_from_format_string`

Source: extract_expressions_from_format_string.rs

Move an expression out of a format string.

#### Before

    fn main() {
        print!("{var} {x + 1}┃");
    }

#### After

    fn main() {
        print!("{var} {}"┃, x + 1);
    }

### `extract_function`

Source: extract_function.rs

Extracts selected statements and comments into new function.

#### Before

    fn main() {
        let n = 1;
        ┃let m = n + 2;
        // calculate
        let k = m + n;┃
        let g = 3;
    }

#### After

    fn main() {
        let n = 1;
        fun_name(n);
        let g = 3;
    }

    fn ┃fun_name(n: i32) {
        let m = n + 2;
        // calculate
        let k = m + n;
    }

### `extract_module`

Source: extract_module.rs

Extracts a selected region as separate module. All the references, visibility and imports are resolved.

#### Before

    ┃fn foo(name: i32) -> i32 {
        name + 1
    }┃

    fn bar(name: i32) -> i32 {
        name + 2
    }

#### After

    mod modname {
        pub(crate) fn foo(name: i32) -> i32 {
            name + 1
        }
    }

    fn bar(name: i32) -> i32 {
        name + 2
    }

### `extract_static`

Source: extract_variable.rs

Extracts subexpression into a static.

#### Before

    fn main() {
        ┃(1 + 2)┃ * 4;
    }

#### After

    fn main() {
        static ┃VAR_NAME: i32 = 1 + 2;
        VAR_NAME * 4;
    }

### `extract_struct_from_enum_variant`

Source: extract_struct_from_enum_variant.rs

Extracts a struct from enum variant.

#### Before

    enum A { ┃One(u32, u32) }

#### After

    struct One(u32, u32);

    enum A { One(One) }

### `extract_type_alias`

Source: extract_type_alias.rs

Extracts the selected type as a type alias.

#### Before

    struct S {
        field: ┃(u8, u8, u8)┃,
    }

#### After

    type ┃Type = (u8, u8, u8);

    struct S {
        field: Type,
    }

### `extract_variable`

Source: extract_variable.rs

Extracts subexpression into a variable.

#### Before

    fn main() {
        ┃(1 + 2)┃ * 4;
    }

#### After

    fn main() {
        let ┃var_name = 1 + 2;
        var_name * 4;
    }

### `fix_visibility`

Source: fix_visibility.rs

Note that there is some duplication between this and the no_such_field diagnostic.

Makes inaccessible item public.

#### Before

    mod m {
        fn frobnicate() {}
    }
    fn main() {
        m::frobnicate┃();
    }

#### After

    mod m {
        ┃pub(crate) fn frobnicate() {}
    }
    fn main() {
        m::frobnicate();
    }

### `flip_binexpr`

Source: flip_binexpr.rs

Flips operands of a binary expression.

#### Before

    fn main() {
        let _ = 90 +┃ 2;
    }

#### After

    fn main() {
        let _ = 2 + 90;
    }

### `flip_comma`

Source: flip_comma.rs

Flips two comma-separated items.

#### Before

    fn main() {
        ((1, 2),┃ (3, 4));
    }

#### After

    fn main() {
        ((3, 4), (1, 2));
    }

### `flip_or_pattern`

Source: flip_or_pattern.rs

Flips two patterns in an or-pattern.

#### Before

    fn foo() {
        let (a |┃ b) = 1;
    }

#### After

    fn foo() {
        let (b | a) = 1;
    }

### `flip_range_expr`

Source: flip_binexpr.rs

Flips operands of a range expression.

#### Before

    fn main() {
        let _ = 90..┃2;
    }

#### After

    fn main() {
        let _ = 2..90;
    }

#### Before

    fn main() {
        let _ = 90..┃;
    }

#### After

    fn main() {
        let _ = ..90;
    }

### `flip_trait_bound`

Source: flip_trait_bound.rs

Flips two trait bounds.

#### Before

    fn foo<T: Clone +┃ Copy>() { }

#### After

    fn foo<T: Copy + Clone>() { }

### `generate_blanket_trait_impl`

Source: generate_blanket_trait_impl.rs

Generate blanket trait implementation.

#### Before

    trait ┃Foo<T: Send>: ToOwned
    where
        Self::Owned: Default,
    {
        fn foo(&self) -> T;

        fn print_foo(&self) {
            println!("{}", self.foo());
        }
    }

#### After

    trait Foo<T: Send>: ToOwned
    where
        Self::Owned: Default,
    {
        fn foo(&self) -> T;

        fn print_foo(&self) {
            println!("{}", self.foo());
        }
    }

    impl<T: Send, T1: ToOwned + ?Sized> Foo<T> for ┃T1
    where
        Self::Owned: Default,
    {
        fn foo(&self) -> T {
            todo!()
        }
    }

### `generate_constant`

Source: generate_constant.rs

Generate a named constant.

#### Before

    struct S { i: usize }
    impl S { pub fn new(n: usize) {} }
    fn main() {
        let v = S::new(CAPA┃CITY);
    }

#### After

    struct S { i: usize }
    impl S { pub fn new(n: usize) {} }
    fn main() {
        const CAPACITY: usize = ┃;
        let v = S::new(CAPACITY);
    }

### `generate_default_from_enum_variant`

Source: generate_default_from_enum_variant.rs

Adds a Default impl for an enum using a variant.

#### Before

    enum Version {
     Undefined,
     Minor┃,
     Major,
    }

#### After

    enum Version {
     Undefined,
     Minor,
     Major,
    }

    impl Default for Version {
        fn default() -> Self {
            Self::Minor
        }
    }

### `generate_default_from_new`

Source: generate_default_from_new.rs

Generates default implementation from new method.

#### Before

    struct Example { _inner: () }

    impl Example {
        pub fn n┃ew() -> Self {
            Self { _inner: () }
        }
    }

#### After

    struct Example { _inner: () }

    impl Example {
        pub fn new() -> Self {
            Self { _inner: () }
        }
    }

    impl Default for Example {
        fn default() -> Self {
            Self::new()
        }
    }

### `generate_delegate_methods`

Source: generate_delegate_methods.rs

Generate delegate methods.

#### Before

    struct Age(u8);
    impl Age {
        fn age(&self) -> u8 {
            self.0
        }
    }

    struct Person {
        ag┃e: Age,
    }

#### After

    struct Age(u8);
    impl Age {
        fn age(&self) -> u8 {
            self.0
        }
    }

    struct Person {
        age: Age,
    }

    impl Person {
        ┃fn age(&self) -> u8 {
            self.age.age()
        }
    }

### `generate_delegate_trait`

Source: generate_delegate_trait.rs

Generate delegate trait implementation for `StructField`s.

#### Before

    trait SomeTrait {
        type T;
        fn fn_(arg: u32) -> u32;
        fn method_(&mut self) -> bool;
    }
    struct A;
    impl SomeTrait for A {
        type T = u32;

        fn fn_(arg: u32) -> u32 {
            42
        }

        fn method_(&mut self) -> bool {
            false
        }
    }
    struct B {
        a┃: A,
    }

#### After

    trait SomeTrait {
        type T;
        fn fn_(arg: u32) -> u32;
        fn method_(&mut self) -> bool;
    }
    struct A;
    impl SomeTrait for A {
        type T = u32;

        fn fn_(arg: u32) -> u32 {
            42
        }

        fn method_(&mut self) -> bool {
            false
        }
    }
    struct B {
        a: A,
    }

    impl SomeTrait for B {
        type T = <A as SomeTrait>::T;

        fn fn_(arg: u32) -> u32 {
            <A as SomeTrait>::fn_(arg)
        }

        fn method_(&mut self) -> bool {
            <A as SomeTrait>::method_(&mut self.a)
        }
    }

### `generate_deref`

Source: generate_deref.rs

Generate `Deref` impl using the given struct field.

#### Before

    struct A;
    struct B {
       ┃a: A
    }

#### After

    struct A;
    struct B {
       a: A
    }

    impl core::ops::Deref for B {
        type Target = A;

        fn deref(&self) -> &Self::Target {
            &self.a
        }
    }

### `generate_derive`

Source: generate_derive.rs

Adds a new `#[derive()]` clause to a struct or enum.

#### Before

    struct Point {
        x: u32,
        y: u32,┃
    }

#### After

    #[derive(┃)]
    struct Point {
        x: u32,
        y: u32,
    }

### `generate_doc_example`

Source: generate_documentation_template.rs

Generates a rustdoc example when editing an item’s documentation.

#### Before

    /// Adds two numbers.┃
    pub fn add(a: i32, b: i32) -> i32 { a + b }

#### After

    /// Adds two numbers.
    ///
    /// # Examples
    ///
    /// ```
    /// use ra_test_fixture::add;
    ///
    /// assert_eq!(add(a, b), );
    /// ```
    pub fn add(a: i32, b: i32) -> i32 { a + b }

### `generate_documentation_template`

Source: generate_documentation_template.rs

Adds a documentation template above a function definition / declaration.

#### Before

    pub struct S;
    impl S {
        pub unsafe fn set_len┃(&mut self, len: usize) -> Result<(), std::io::Error> {
            /* ... */
        }
    }

#### After

    pub struct S;
    impl S {
        /// Sets the length of this [`S`].
        ///
        /// # Errors
        ///
        /// This function will return an error if .
        ///
        /// # Safety
        ///
        /// .
        pub unsafe fn set_len(&mut self, len: usize) -> Result<(), std::io::Error> {
            /* ... */
        }
    }

### `generate_enum_as_method`

Source: generate_enum_projection_method.rs

Generate an `as_` method for this enum variant.

#### Before

    enum Value {
     Number(i32),
     Text(String)┃,
    }

#### After

    enum Value {
     Number(i32),
     Text(String),
    }

    impl Value {
        fn as_text(&self) -> Option<&String> {
            if let Self::Text(v) = self {
                Some(v)
            } else {
                None
            }
        }
    }

### `generate_enum_is_method`

Source: generate_enum_is_method.rs

Generate an `is_` method for this enum variant.

#### Before

    enum Version {
     Undefined,
     Minor┃,
     Major,
    }

#### After

    enum Version {
     Undefined,
     Minor,
     Major,
    }

    impl Version {
        /// Returns `true` if the version is [`Minor`].
        ///
        /// [`Minor`]: Version::Minor
        #[must_use]
        fn is_minor(&self) -> bool {
            matches!(self, Self::Minor)
        }
    }

### `generate_enum_try_into_method`

Source: generate_enum_projection_method.rs

Generate a `try_into_` method for this enum variant.

#### Before

    enum Value {
     Number(i32),
     Text(String)┃,
    }

#### After

    enum Value {
     Number(i32),
     Text(String),
    }

    impl Value {
        fn try_into_text(self) -> Result<String, Self> {
            if let Self::Text(v) = self {
                Ok(v)
            } else {
                Err(self)
            }
        }
    }

### `generate_enum_variant`

Source: generate_enum_variant.rs

Adds a variant to an enum.

#### Before

    enum Countries {
        Ghana,
    }

    fn main() {
        let country = Countries::Lesotho┃;
    }

#### After

    enum Countries {
        Ghana,
        Lesotho,
    }

    fn main() {
        let country = Countries::Lesotho;
    }

### `generate_fn_type_alias_named`

Source: generate_fn_type_alias.rs

Generate a type alias for the function with named parameters.

#### Before

    unsafe fn fo┃o(n: i32) -> i32 { 42i32 }

#### After

    type ${0:FooFn} = unsafe fn(n: i32) -> i32;

    unsafe fn foo(n: i32) -> i32 { 42i32 }

### `generate_fn_type_alias_unnamed`

Source: generate_fn_type_alias.rs

Generate a type alias for the function with unnamed parameters.

#### Before

    unsafe fn fo┃o(n: i32) -> i32 { 42i32 }

#### After

    type ${0:FooFn} = unsafe fn(i32) -> i32;

    unsafe fn foo(n: i32) -> i32 { 42i32 }

### `generate_from_impl_for_enum`

Source: generate_from_impl_for_enum.rs

Adds a From impl for this enum variant with one tuple field.

#### Before

    enum A { ┃One(u32) }

#### After

    enum A { One(u32) }

    impl From<u32> for A {
        fn from(v: u32) -> Self {
            Self::One(v)
        }
    }

### `generate_function`

Source: generate_function.rs

Adds a stub function with a signature matching the function under the cursor.

#### 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: &'static str, baz: Baz) ${0:-> _} {
        todo!()
    }

### `generate_getter`

Source: generate_getter_or_setter.rs

Generate a getter method.

#### Before

    struct Person {
        nam┃e: String,
    }

#### After

    struct Person {
        name: String,
    }

    impl Person {
        fn ┃name(&self) -> &str {
            &self.name
        }
    }

### `generate_getter_mut`

Source: generate_getter_or_setter.rs

Generate a mut getter method.

#### Before

    struct Person {
        nam┃e: String,
    }

#### After

    struct Person {
        name: String,
    }

    impl Person {
        fn ┃name_mut(&mut self) -> &mut String {
            &mut self.name
        }
    }

### `generate_impl`

Source: generate_impl.rs

Adds a new inherent impl for a type.

#### Before

    struct Ctx┃<T: Clone> {
        data: T,
    }

#### After

    struct Ctx<T: Clone> {
        data: T,
    }

    impl<T: Clone> Ctx<T> {┃}

### `generate_impl_trait`

Source: generate_impl.rs

Adds this trait impl for a type.

#### Before

    trait ┃Foo {
        fn foo(&self) -> i32;
    }

#### After

    trait Foo {
        fn foo(&self) -> i32;
    }

    impl Foo for ${1:_} {
        fn foo(&self) -> i32 {
            ┃todo!()
        }
    }

### `generate_is_empty_from_len`

Source: generate_is_empty_from_len.rs

Generates is_empty implementation from the len method.

#### Before

    struct MyStruct { data: Vec<String> }

    impl MyStruct {
        #[must_use]
        p┃ub fn len(&self) -> usize {
            self.data.len()
        }
    }

#### After

    struct MyStruct { data: Vec<String> }

    impl MyStruct {
        #[must_use]
        pub fn len(&self) -> usize {
            self.data.len()
        }

        #[must_use]
        pub fn is_empty(&self) -> bool {
            self.len() == 0
        }
    }

### `generate_mut_trait_impl`

Source: generate_mut_trait_impl.rs

Adds a IndexMut impl from the `Index` trait.

#### Before

    pub enum Axis { X = 0, Y = 1, Z = 2 }

    impl<T> core::ops::Index┃<Axis> for [T; 3] {
        type Output = T;

        fn index(&self, index: Axis) -> &Self::Output {
            &self[index as usize]
        }
    }

#### After

    pub enum Axis { X = 0, Y = 1, Z = 2 }

    ┃impl<T> core::ops::IndexMut<Axis> for [T; 3] {
        fn index_mut(&mut self, index: Axis) -> &mut Self::Output {
            &mut self[index as usize]
        }
    }

    impl<T> core::ops::Index<Axis> for [T; 3] {
        type Output = T;

        fn index(&self, index: Axis) -> &Self::Output {
            &self[index as usize]
        }
    }

### `generate_new`

Source: generate_new.rs

Adds a `fn new` for a type.

#### 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 }
        }
    }

### `generate_setter`

Source: generate_getter_or_setter.rs

Generate a setter method.

#### Before

    struct Person {
        nam┃e: String,
    }

#### After

    struct Person {
        name: String,
    }

    impl Person {
        fn ┃set_name(&mut self, name: String) {
            self.name = name;
        }
    }

### `generate_single_field_struct_from`

Source: generate_single_field_struct_from.rs

Implement From for a single field structure, ignore trivial types.

#### Before

    use core::marker::PhantomData;
    struct ┃Foo<T> {
        id: i32,
        _phantom_data: PhantomData<T>,
    }

#### After

    use core::marker::PhantomData;
    struct Foo<T> {
        id: i32,
        _phantom_data: PhantomData<T>,
    }

    impl<T> From<i32> for Foo<T> {
        fn from(id: i32) -> Self {
            Self { id, _phantom_data: PhantomData }
        }
    }

### `generate_trait_from_impl`

Source: generate_trait_from_impl.rs

Generate trait for an already defined inherent impl and convert impl to a trait impl.

#### Before

    struct Foo<const N: usize>([i32; N]);

    macro_rules! const_maker {
        ($t:ty, $v:tt) => {
            const CONST: $t = $v;
        };
    }

    impl<const N: usize> Fo┃o<N> {
        // Used as an associated constant.
        const CONST_ASSOC: usize = N * 4;

        fn create() -> Option<()> {
            Some(())
        }

        const_maker! {i32, 7}
    }

#### After

    struct Foo<const N: usize>([i32; N]);

    macro_rules! const_maker {
        ($t:ty, $v:tt) => {
            const CONST: $t = $v;
        };
    }

    trait ${0:NewTrait}<const N: usize> {
        // Used as an associated constant.
        const CONST_ASSOC: usize = N * 4;

        fn create() -> Option<()>;

        const_maker! {i32, 7}
    }

    impl<const N: usize> ${0:NewTrait}<N> for Foo<N> {
        // Used as an associated constant.
        const CONST_ASSOC: usize = N * 4;

        fn create() -> Option<()> {
            Some(())
        }

        const_maker! {i32, 7}
    }

### `generate_trait_impl`

Source: generate_impl.rs

Adds a new trait impl for a type.

#### Before

    struct ┃Ctx<T: Clone> {
        data: T,
    }

#### After

    struct Ctx<T: Clone> {
        data: T,
    }

    impl<T: Clone> ${1:_} for Ctx<T> {┃}

### `inline_call`

Source: inline_call.rs

Inlines a function or method body creating a `let` statement per parameter unless the parameter can be inlined. The parameter will be inlined either if it the supplied argument is a simple local or if the parameter is only accessed inside the function body once.

#### Before

    fn foo(name: Option<&str>) {
        let name = name.unwrap┃();
    }

#### After

    fn foo(name: Option<&str>) {
        let name = match name {
                Some(val) => val,
                None => panic!("called `Option::unwrap()` on a `None` value"),
            };
    }

### `inline_const_as_literal`

Source: inline_const_as_literal.rs

Evaluate and inline const variable as literal.

#### Before

    const STRING: &str = "Hello, World!";

    fn something() -> &'static str {
        STRING┃
    }

#### After

    const STRING: &str = "Hello, World!";

    fn something() -> &'static str {
        "Hello, World!"
    }

### `inline_into_callers`

Source: inline_call.rs

Inline a function or method body into all of its callers where possible, creating a `let` statement per parameter unless the parameter can be inlined. The parameter will be inlined either if it the supplied argument is a simple local or if the parameter is only accessed inside the function body once. If all calls can be inlined the function will be removed.

#### Before

    fn print(_: &str) {}
    fn foo┃(word: &str) {
        if !word.is_empty() {
            print(word);
        }
    }
    fn bar() {
        foo("안녕하세요");
        foo("여러분");
    }

#### After

    fn print(_: &str) {}

    fn bar() {
        {
            let word: &str = "안녕하세요";
            if !word.is_empty() {
                print(word);
            }
        };
        {
            let word: &str = "여러분";
            if !word.is_empty() {
                print(word);
            }
        };
    }

### `inline_local_variable`

Source: inline_local_variable.rs

Inlines a local variable.

#### Before

    fn main() {
        let x┃ = 1 + 2;
        x * 4;
    }

#### After

    fn main() {
        (1 + 2) * 4;
    }

### `inline_macro`

Source: inline_macro.rs

Takes a macro and inlines it one step.

#### Before

    macro_rules! num {
        (+$($t:tt)+) => (1 + num!($($t )+));
        (-$($t:tt)+) => (-1 + num!($($t )+));
        (+) => (1);
        (-) => (-1);
    }

    fn main() {
        let number = num┃!(+ + + - + +);
        println!("{number}");
    }

#### After

    macro_rules! num {
        (+$($t:tt)+) => (1 + num!($($t )+));
        (-$($t:tt)+) => (-1 + num!($($t )+));
        (+) => (1);
        (-) => (-1);
    }

    fn main() {
        let number = 1+num!(+ + - + +);
        println!("{number}");
    }

### `inline_type_alias`

Source: inline_type_alias.rs

Replace a type alias with its concrete type.

#### Before

    type A<T = u32> = Vec<T>;

    fn main() {
        let a: ┃A;
    }

#### After

    type A<T = u32> = Vec<T>;

    fn main() {
        let a: Vec<u32>;
    }

### `inline_type_alias_uses`

Source: inline_type_alias.rs

Inline a type alias into all of its uses where possible.

#### Before

    type ┃A = i32;
    fn id(x: A) -> A {
        x
    };
    fn foo() {
        let _: A = 3;
    }

#### After

    fn id(x: i32) -> i32 {
        x
    };
    fn foo() {
        let _: i32 = 3;
    }

### `into_to_qualified_from`

Source: into_to_qualified_from.rs

Convert an `into` method call to a fully qualified `from` call.

#### Before

    //- minicore: from
    struct B;
    impl From<i32> for B {
        fn from(a: i32) -> Self {
           B
        }
    }

    fn main() -> () {
        let a = 3;
        let b: B = a.in┃to();
    }

#### After

    struct B;
    impl From<i32> for B {
        fn from(a: i32) -> Self {
           B
        }
    }

    fn main() -> () {
        let a = 3;
        let b: B = B::from(a);
    }

### `introduce_named_lifetime`

Source: introduce_named_lifetime.rs

Change an anonymous lifetime to a named lifetime.

#### Before

    impl Cursor<'_┃> {
        fn node(self) -> &SyntaxNode {
            match self {
                Cursor::Replace(node) | Cursor::Before(node) => node,
            }
        }
    }

#### After

    impl<'a> Cursor<'a> {
        fn node(self) -> &SyntaxNode {
            match self {
                Cursor::Replace(node) | Cursor::Before(node) => node,
            }
        }
    }

### `introduce_named_type_parameter`

Source: introduce_named_type_parameter.rs

Replaces `impl Trait` function argument with the named generic.

#### Before

    fn foo(bar: ┃impl Bar) {}

#### After

    fn foo<┃B: Bar>(bar: B) {}

### `invert_if`

Source: invert_if.rs

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

    fn main() {
        if┃ !y { A } else { B }
    }

#### After

    fn main() {
        if y { B } else { A }
    }

### `line_to_block`

Source: convert_comment_block.rs

Converts comments between block and single-line form.

#### Before

       // Multi-line┃
       // comment

#### After

      /*
      Multi-line
      comment
      */

### `make_raw_string`

Source: raw_string.rs

Adds `r#` to a plain string literal.

#### Before

    fn main() {
        "Hello,┃ World!";
    }

#### After

    fn main() {
        r#"Hello, World!"#;
    }

### `make_usual_string`

Source: raw_string.rs

Turns a raw string into a plain string.

#### Before

    fn main() {
        r#"Hello,┃ "World!""#;
    }

#### After

    fn main() {
        "Hello, \"World!\"";
    }

### `merge_imports`

Source: merge_imports.rs

Merges neighbor imports with a common prefix.

#### Before

    use std::┃fmt::Formatter;
    use std::io;

#### After

    use std::{fmt::Formatter, io};

### `merge_match_arms`

Source: merge_match_arms.rs

Merges the current match arm with the following if their bodies are identical.

#### 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(),
        }
    }

### `merge_nested_if`

Source: merge_nested_if.rs

This transforms if expressions of the form `if x { if y {A} }` into `if x && y {A}` This assist can only be applied with the cursor on `if`.

#### Before

    fn main() {
       i┃f x == 3 { if y == 4 { 1 } }
    }

#### After

    fn main() {
       if x == 3 && y == 4 { 1 }
    }

### `move_arm_cond_to_match_guard`

Source: move_guard.rs

Moves if expression from match arm body into a guard.

#### 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`

Source: move_bounds.rs

Moves inline type bounds to a where clause.

#### 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_const_to_impl`

Source: move_const_to_impl.rs

Move a local constant item in a method to impl’s associated constant. All the references will be qualified with `Self::`.

#### Before

    struct S;
    impl S {
        fn foo() -> usize {
            /// The answer.
            const C┃: usize = 42;

            C * C
        }
    }

#### After

    struct S;
    impl S {
        /// The answer.
        const C: usize = 42;

        fn foo() -> usize {
            Self::C * Self::C
        }
    }

### `move_from_mod_rs`

Source: move_from_mod_rs.rs

Moves xxx/mod.rs to xxx.rs.

#### Before

    //- /main.rs
    mod a;
    //- /a/mod.rs
    ┃fn t() {}┃

#### After

    fn t() {}

### `move_guard_to_arm_body`

Source: move_guard.rs

Moves match guard into match arm body.

#### 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_module_to_file`

Source: move_module_to_file.rs

Moves inline module’s contents to a separate file.

#### Before

    mod ┃foo {
        fn t() {}
    }

#### After

    mod foo;

### `move_to_mod_rs`

Source: move_to_mod_rs.rs

Moves xxx.rs to xxx/mod.rs.

#### Before

    //- /main.rs
    mod a;
    //- /a.rs
    ┃fn t() {}┃

#### After

    fn t() {}

### `normalize_import`

Source: normalize_import.rs

Normalizes an import.

#### Before

    use┃ std::{io, {fmt::Formatter}};

#### After

    use std::{fmt::Formatter, io};

### `promote_local_to_const`

Source: promote_local_to_const.rs

Promotes a local variable to a const item changing its name to a `SCREAMING_SNAKE_CASE` variant if the local uses no non-const expressions.

#### Before

    fn main() {
        let foo┃ = true;

        if foo {
            println!("It's true");
        } else {
            println!("It's false");
        }
    }

#### After

    fn main() {
        const ┃FOO: bool = true;

        if FOO {
            println!("It's true");
        } else {
            println!("It's false");
        }
    }

### `pull_assignment_up`

Source: pull_assignment_up.rs

Extracts variable assignment to outside an if or match statement.

#### Before

    fn main() {
        let mut foo = 6;

        if true {
            ┃foo = 5;
        } else {
            foo = 4;
        }
    }

#### After

    fn main() {
        let mut foo = 6;

        foo = if true {
            5
        } else {
            4
        };
    }

### `qualify_method_call`

Source: qualify_method_call.rs

Replaces the method call with a qualified function call.

#### Before

    struct Foo;
    impl Foo {
        fn foo(&self) {}
    }
    fn main() {
        let foo = Foo;
        foo.fo┃o();
    }

#### After

    struct Foo;
    impl Foo {
        fn foo(&self) {}
    }
    fn main() {
        let foo = Foo;
        Foo::foo(&foo);
    }

### `qualify_path`

Source: qualify_path.rs

If the name is unresolved, provides all possible qualified paths for it.

#### Before

    fn main() {
        let map = HashMap┃::new();
    }

#### After

    fn main() {
        let map = std::collections::HashMap::new();
    }

### `reformat_number_literal`

Source: number_representation.rs

Adds or removes separators from integer literal.

#### Before

    const _: i32 = 1012345┃;

#### After

    const _: i32 = 1_012_345;

### `remove_dbg`

Source: remove_dbg.rs

Removes `dbg!()` macro call.

#### Before

    fn main() {
        let x = ┃dbg!(42 * dbg!(4 + 2));┃
    }

#### After

    fn main() {
        let x = 42 * (4 + 2);
    }

### `remove_else_branches`

Source: remove_else_branches.rs

Removes the `else` keyword and else branches.

#### Before

    fn main() {
        if true {
            let _ = 2;
        } ┃else {
            unreachable!();
        }
    }

#### After

    fn main() {
        if true {
            let _ = 2;
        }
    }

#### Before

    fn main() {
        let _x = 2 ┃else { unreachable!() };
    }

#### After

    fn main() {
        let _x = 2;
    }

### `remove_hash`

Source: raw_string.rs

Removes a hash from a raw string literal.

#### Before

    fn main() {
        r#"Hello,┃ World!"#;
    }

#### After

    fn main() {
        r"Hello, World!";
    }

### `remove_mut`

Source: remove_mut.rs

Removes the `mut` keyword.

#### Before

    impl Walrus {
        fn feed(&mut┃ self, amount: u32) {}
    }

#### After

    impl Walrus {
        fn feed(&self, amount: u32) {}
    }

### `remove_parentheses`

Source: remove_parentheses.rs

Removes redundant parentheses.

#### Before

    fn main() {
        _ = ┃(2) + 2;
    }

#### After

    fn main() {
        _ = 2 + 2;
    }

### `remove_underscore_from_used_variables`

Source: remove_underscore.rs

Removes underscore from used variables.

#### Before

    fn main() {
        let mut _┃foo = 1;
        _foo = 2;
    }

#### After

    fn main() {
        let mut foo = 1;
        foo = 2;
    }

### `remove_unused_imports`

Source: remove_unused_imports.rs

Removes any use statements in the current selection that are unused.

#### Before

    struct X();
    mod foo {
        use super::X┃;
    }

#### After

    struct X();
    mod foo {
    }

### `remove_unused_param`

Source: remove_unused_param.rs

Removes unused function parameter.

#### Before

    fn frobnicate(x: i32┃) {}

    fn main() {
        frobnicate(92);
    }

#### After

    fn frobnicate() {}

    fn main() {
        frobnicate();
    }

### `reorder_fields`

Source: reorder_fields.rs

Reorder the fields of record literals and record patterns in the same order as in the definition.

#### 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}

### `reorder_impl_items`

Source: reorder_impl_items.rs

Reorder the items of an `impl Trait`. The items will be ordered in the same order as in the trait definition.

#### Before

    trait Foo {
        type A;
        const B: u8;
        fn c();
    }

    struct Bar;
    ┃impl Foo for Bar┃ {
        const B: u8 = 17;
        fn c() {}
        type A = String;
    }

#### After

    trait Foo {
        type A;
        const B: u8;
        fn c();
    }

    struct Bar;
    impl Foo for Bar {
        type A = String;
        const B: u8 = 17;
        fn c() {}
    }

### `replace_arith_with_checked`

Source: replace_arith_op.rs

Replaces arithmetic on integers with the `checked_*` equivalent.

#### Before

    fn main() {
      let x = 1 ┃+ 2;
    }

#### After

    fn main() {
      let x = 1.checked_add(2);
    }

### `replace_arith_with_saturating`

Source: replace_arith_op.rs

Replaces arithmetic on integers with the `saturating_*` equivalent.

#### Before

    fn main() {
      let x = 1 ┃+ 2;
    }

#### After

    fn main() {
      let x = 1.saturating_add(2);
    }

### `replace_arith_with_wrapping`

Source: replace_arith_op.rs

Replaces arithmetic on integers with the `wrapping_*` equivalent.

#### Before

    fn main() {
      let x = 1 ┃+ 2;
    }

#### After

    fn main() {
      let x = 1.wrapping_add(2);
    }

### `replace_char_with_string`

Source: replace_string_with_char.rs

Replace a char literal with a string literal.

#### Before

    fn main() {
        find('{┃');
    }

#### After

    fn main() {
        find("{");
    }

### `replace_derive_with_manual_impl`

Source: replace_derive_with_manual_impl.rs

Converts a `derive` impl into a manual one.

#### Before

    #[derive(Deb┃ug, Display)]
    struct S;

#### After

    #[derive(Display)]
    struct S;

    impl Debug for S {
        ┃fn fmt(&self, f: &mut Formatter) -> Result<()> {
            f.debug_struct("S").finish()
        }
    }

### `replace_if_let_with_match`

Source: replace_if_let_with_match.rs

Replaces a `if let` expression with a `match` expression.

#### 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_is_some_with_if_let_some`

Source: replace_is_method_with_if_let_method.rs

Replace `if x.is_some()` with `if let Some(_tmp) = x` or `if x.is_ok()` with `if let Ok(_tmp) = x`.

#### Before

    fn main() {
        let x = Some(1);
        if x.is_som┃e() {}
    }

#### After

    fn main() {
        let x = Some(1);
        if let Some(${0:x1}) = x {}
    }

### `replace_let_with_if_let`

Source: replace_let_with_if_let.rs

Replaces `let` with an `if let`.

#### 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_match_with_if_let`

Source: replace_if_let_with_match.rs

Replaces a binary `match` with a wildcard pattern with an `if let` expression.

#### Before

    enum Action { Move { distance: u32 }, Stop }

    fn handle(action: Action) {
        ┃match action {
            Action::Move { distance } => foo(distance),
            _ => bar(),
        }
    }

#### After

    enum Action { Move { distance: u32 }, Stop }

    fn handle(action: Action) {
        if let Action::Move { distance } = action {
            foo(distance)
        } else {
            bar()
        }
    }

### `replace_named_generic_with_impl`

Source: replace_named_generic_with_impl.rs

Replaces named generic with an `impl Trait` in function argument.

#### Before

    fn new<P┃: AsRef<Path>>(location: P) -> Self {}

#### After

    fn new(location: impl AsRef<Path>) -> Self {}

### `replace_qualified_name_with_use`

Source: replace_qualified_name_with_use.rs

Adds a use statement for a given fully-qualified name.

#### Before

    fn process(map: std::collections::┃HashMap<String, String>) {}

#### After

    use std::collections::HashMap;

    fn process(map: HashMap<String, String>) {}

### `replace_string_with_char`

Source: replace_string_with_char.rs

Replace string literal with char literal.

#### Before

    fn main() {
        find("{┃");
    }

#### After

    fn main() {
        find('{');
    }

### `replace_turbofish_with_explicit_type`

Source: replace_turbofish_with_explicit_type.rs

Converts `::<_>` to an explicit type assignment.

#### Before

    fn make<T>() -> T { ) }
    fn main() {
        let a = make┃::<i32>();
    }

#### After

    fn make<T>() -> T { ) }
    fn main() {
        let a: i32 = make();
    }

### `replace_with_eager_method`

Source: replace_method_eager_lazy.rs

Replace `unwrap_or_else` with `unwrap_or` and `ok_or_else` with `ok_or`.

#### Before

    fn foo() {
        let a = Some(1);
        a.unwra┃p_or_else(|| 2);
    }

#### After

    fn foo() {
        let a = Some(1);
        a.unwrap_or(2);
    }

### `replace_with_lazy_method`

Source: replace_method_eager_lazy.rs

Replace `unwrap_or` with `unwrap_or_else` and `ok_or` with `ok_or_else`.

#### Before

    fn foo() {
        let a = Some(1);
        a.unwra┃p_or(2);
    }

#### After

    fn foo() {
        let a = Some(1);
        a.unwrap_or_else(|| 2);
    }

### `sort_items`

Source: sort_items.rs

Sorts item members alphabetically: fields, enum variants and methods.

#### Before

    struct ┃Foo┃ { second: u32, first: String }

#### After

    struct Foo { first: String, second: u32 }

#### Before

    trait ┃Bar┃ {
        fn second(&self) -> u32;
        fn first(&self) -> String;
    }

#### After

    trait Bar {
        fn first(&self) -> String;
        fn second(&self) -> u32;
    }

#### Before

    struct Baz;
    impl ┃Baz┃ {
        fn second(&self) -> u32;
        fn first(&self) -> String;
    }

#### After

    struct Baz;
    impl Baz {
        fn first(&self) -> String;
        fn second(&self) -> u32;
    }

There is a difference between sorting enum variants:

#### Before

    enum ┃Animal┃ {
      Dog(String, f64),
      Cat { weight: f64, name: String },
    }

#### After

    enum Animal {
      Cat { weight: f64, name: String },
      Dog(String, f64),
    }

and sorting a single enum struct variant:

#### Before

    enum Animal {
      Dog(String, f64),
      Cat ┃{ weight: f64, name: String }┃,
    }

#### After

    enum Animal {
      Dog(String, f64),
      Cat { name: String, weight: f64 },
    }

### `split_import`

Source: split_import.rs

Wraps the tail of import into braces.

#### Before

    use std::┃collections::HashMap;

#### After

    use std::{collections::HashMap};

### `sugar_impl_future_into_async`

Source: toggle_async_sugar.rs

Rewrites asynchronous function from `-> impl Future` into `async fn`. This action does not touch the function body and therefore `async { 0 }` block does not transform to just `0`.

#### Before

    pub fn foo() -> impl core::future::F┃uture<Output = usize> {
        async { 0 }
    }

#### After

    pub async fn foo() -> usize {
        async { 0 }
    }

### `toggle_ignore`

Source: toggle_ignore.rs

Adds `#[ignore]` attribute to the test.

#### Before

    ┃#[test]
    fn arithmetics {
        assert_eq!(2 + 2, 5);
    }

#### After

    #[test]
    #[ignore]
    fn arithmetics {
        assert_eq!(2 + 2, 5);
    }

### `toggle_macro_delimiter`

Source: toggle_macro_delimiter.rs

Change macro delimiters in the order of `( -> { -> [ -> (`.

#### Before

    macro_rules! sth {
        () => {};
    }

    sth!┃( );

#### After

    macro_rules! sth {
        () => {};
    }

    sth!{ }

### `unmerge_imports`

Source: unmerge_imports.rs

Extracts a use item from a use list into a standalone use list.

#### Before

    use std::fmt::{Debug, Display┃};

#### After

    use std::fmt::{Debug};
    use std::fmt::Display;

### `unmerge_match_arm`

Source: unmerge_match_arm.rs

Splits the current match with a `|` pattern into two arms with identical bodies.

#### Before

    enum Action { Move { distance: u32 }, Stop }

    fn handle(action: Action) {
        match action {
            Action::Move(..) ┃| Action::Stop => foo(),
        }
    }

#### After

    enum Action { Move { distance: u32 }, Stop }

    fn handle(action: Action) {
        match action {
            Action::Move(..) => foo(),
            Action::Stop => foo(),
        }
    }

### `unnecessary_async`

Source: unnecessary_async.rs

Removes the `async` mark from functions which have no `.await` in their body. Looks for calls to the functions and removes the `.await` on the call site.

#### Before

    pub asy┃nc fn foo() {}
    pub async fn bar() { foo().await }

#### After

    pub fn foo() {}
    pub async fn bar() { foo() }

### `unqualify_method_call`

Source: unqualify_method_call.rs

Transforms universal function call syntax into a method call.

#### Before

    fn main() {
        std::ops::Add::add┃(1, 2);
    }

#### After

    use std::ops::Add;

    fn main() {
        1.add(2);
    }

### `unwrap_block`

Source: unwrap_block.rs

This assist removes if…else, for, while and loop control statements to just keep the body.

#### Before

    fn foo() {
        if true {┃
            println!("foo");
        }
    }

#### After

    fn foo() {
        println!("foo");
    }

### `unwrap_option_return_type`

Source: unwrap_return_type.rs

Unwrap the function’s return type.

#### Before

    fn foo() -> Option<i32>┃ { Some(42i32) }

#### After

    fn foo() -> i32 { 42i32 }

### `unwrap_result_return_type`

Source: unwrap_return_type.rs

Unwrap the function’s return type.

#### Before

    fn foo() -> Result<i32>┃ { Ok(42i32) }

#### After

    fn foo() -> i32 { 42i32 }

### `unwrap_tuple`

Source: unwrap_tuple.rs

Unwrap the tuple to different variables.

#### Before

    fn main() {
        ┃let (foo, bar) = ("Foo", "Bar");
    }

#### After

    fn main() {
        let foo = "Foo";
        let bar = "Bar";
    }

### `unwrap_type_to_generic_arg`

Source: unwrap_type_to_generic_arg.rs

This assist unwraps a type into its generic type argument.

#### Before

    fn foo() -> ┃Option<i32> {
        todo!()
    }

#### After

    fn foo() -> i32 {
        todo!()
    }

### `wrap_return_type_in_option`

Source: wrap_return_type.rs

Wrap the function’s return type into Option.

#### Before

    fn foo() -> i32┃ { 42i32 }

#### After

    fn foo() -> Option<i32> { Some(42i32) }

### `wrap_return_type_in_result`

Source: wrap_return_type.rs

Wrap the function’s return type into Result.

#### Before

    fn foo() -> i32┃ { 42i32 }

#### After

    fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }

### `wrap_unwrap_cfg_attr`

Source: wrap_unwrap_cfg_attr.rs

Wraps an attribute to a cfg_attr attribute or unwraps a cfg_attr attribute to the inner attributes.

#### Before

    #[derive┃(Debug)]
    struct S {
       field: i32
    }

#### After

    #[cfg_attr(┃, derive(Debug))]
    struct S {
       field: i32
    }