Skip to content

Latest commit

 

History

History
3925 lines (3043 loc) · 69.6 KB

generated_assists.adoc

File metadata and controls

3925 lines (3043 loc) · 69.6 KB
Raw

add_braces

Source: add_braces.rs

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

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

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

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

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

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

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

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

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

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

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

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

Adds or changes existing visibility specifier.

Before
┃fn frobnicate() {}
After
pub(crate) fn frobnicate() {}

comment_to_doc

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

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

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

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

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

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

Converts the base of integer literals to other bases.

Before
const _: i32 = 10┃;
After
const _: i32 = 0b1010;

convert_into_to_from

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

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

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

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

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

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

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

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

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

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

Replace a while with a loop.

Before
fn main() {
    ┃while cond {
        foo();
    }
}
After
fn main() {
    loop {
        if !cond {
            break;
        }
        foo();
    }
}

destructure_struct_binding

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

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

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

Desugars doc-comments to the attribute form.

Before
/// Multi-line┃
/// comment
After
#[doc = r"Multi-line
comment"]

expand_glob_import

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

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_expressions_from_format_string

Move an expression out of a format string.

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

extract_function

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

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_struct_from_enum_variant

Extracts a struct from enum variant.

Before
enum A { ┃One(u32, u32) }
After
struct One(u32, u32);

enum A { One(One) }

extract_type_alias

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

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

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

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

Flips two trait bounds.

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

generate_constant

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

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

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

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

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

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

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

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 test::add;
///
/// assert_eq!(add(a, b), );
/// ```
pub fn add(a: i32, b: i32) -> i32 { a + b }

generate_documentation_template

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Merges neighbor imports with a common prefix.

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

merge_match_arms

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

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

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

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

Moves inline module’s contents to a separate file.

Before
mod ┃foo {
    fn t() {}
}
After
mod foo;

move_to_mod_rs

Moves xxx.rs to xxx/mod.rs.

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

normalize_import

Normalizes an import.

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

promote_local_to_const

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

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

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

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

Removes redundant parentheses.

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

remove_unused_imports

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

Removes unused function parameter.

Before
fn frobnicate(x: i32┃) {}

fn main() {
    frobnicate(92);
}
After
fn frobnicate() {}

fn main() {
    frobnicate();
}

reorder_fields

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

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

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

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

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

Replace a char literal with a string literal.

Before
fn main() {
    find('{┃');
}
After
fn main() {
    find("{");
}

replace_derive_with_manual_impl

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

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

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:x}) = x {}
}

replace_let_with_if_let

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

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

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

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

Replace string literal with char literal.

Before
fn main() {
    find("{┃");
}
After
fn main() {
    find('{');
}

replace_try_expr_with_match

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

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

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

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

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

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

Change macro delimiters in the order of ( → { → [ → (.

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

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

sth!{ }

unmerge_match_arm

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

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 async f┃n foo() {}
pub async fn bar() { foo().await }
After
pub fn foo() {}
pub async fn bar() { foo() }

unqualify_method_call

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

Unwrap the function’s return type.

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

unwrap_result_return_type

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

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

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

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
}