rust-analyzer

//! Generated by cargo xtask codegen assists-doc-tests, do not edit by hand.

`add_braces`

Adds braces to lambda and match arm expressions.

Before

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

After

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

`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() {
    'l: loop {
        break 'l;
        continue '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!()},┃
    }
}

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

`bool_to_enum`

Source: 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");
    }
}

`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_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_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_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();
}

`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"]

`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) {}

`explicit_enum_discriminant`

Source: 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,
}

`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;
}

`fill_record_pattern_fields`

Source: fill_record_pattern_fields.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;
}

`fix_visibility`

Source: fix_visibility.rs

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

Source: flip_trait_bound.rs

Flips two trait bounds.

Before

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

After

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

`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 StructFields.

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: &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_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 {
        &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_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> ${0:_} 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_generic`

Source: introduce_named_generic.rs

Replaces impl Trait function argument with the named generic.

Before

fn foo(bar: ┃impl Bar) {}

After

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

`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,
        }
    }
}

`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_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_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 and no guards 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_try_expr_with_match`

Source: replace_try_expr_with_match.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,
    };
}

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

`unmerge_use`

Source: unmerge_use.rs

Extracts single use item from use list.

Before

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

After

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

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

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