1
2
3
4
5
6
fn foo(n: i32) -> i32 {
match n {
1 =>┃ n + 1,
_ => 0
}
}
add_braces
Source: add_braces.rs
Adds braces to lambda and match arm expressions.
Before
After
1
2
3
4
5
6
7
8
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
1
2
3
fn main() {
let x┃ = 92;
}
After
1
2
3
fn main() {
let x: i32 = 92;
}
add_hash
Source: raw_string.rs
Adds a hash to a raw string literal.
Before
1
2
3
fn main() {
r#"Hello,┃ World!"#;
}
After
1
2
3
fn main() {
r##"Hello, World!"##;
}
add_impl_default_members
Source: add_missing_impl_members.rs
Adds scaffold for overriding default impl members.
Before
1
2
3
4
5
6
7
8
9
10
trait Trait {
type X;
fn foo(&self);
fn bar(&self) {}
}
impl Trait for () {
type X = ();
fn foo(&self) {}┃
}
After
1
2
3
4
5
6
7
8
9
10
11
12
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
1
2
3
4
5
6
7
8
9
trait Trait<T> {
type X;
fn foo(&self) -> T;
fn bar(&self) {}
}
impl Trait<u32> for () {┃
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
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
1
2
3
4
5
6
fn main() {
loop┃ {
break;
continue;
}
}
After
1
2
3
4
5
6
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
1
2
3
4
struct Point {
x: &┃u32,
y: u32,
}
After
1
2
3
4
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
1
2
3
4
5
6
7
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
match action {
┃
}
}
After
1
2
3
4
5
6
7
8
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
match action {
┃Action::Move { distance } => todo!(),
Action::Stop => 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
1
fn foo() { 4┃2i32 }
After
1
fn foo() -> i32 { 42i32 }
add_turbo_fish
Source: add_turbo_fish.rs
Adds ::<_> to a call of a generic method or function.
Before
1
2
3
4
fn make<T>() -> T { todo!() }
fn main() {
let x = make┃();
}
After
1
2
3
4
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
1
2
3
fn main() {
if x != 4 ||┃ y < 3.14 {}
}
After
1
2
3
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
1
2
3
4
5
6
fn main() {
let arr = [1, 2, 3];
if !arr.into_iter().┃any(|num| num == 4) {
println!("foo");
}
}
After
1
2
3
4
5
6
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
1
2
3
fn main() {
let map = HashMap┃::new();
}
After
1
2
3
4
5
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
1
fn some_function(x: i32┃) {}
After
1
2
3
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
1
2
3
4
5
6
7
fn main() {
let ┃bool = true;
if bool {
println!("foo");
}
}
After
1
2
3
4
5
6
7
8
9
10
#[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
1
┃fn frobnicate() {}
After
1
pub(crate) fn frobnicate() {}
comment_to_doc
Converts comments to documentation.
Before
1
2
// Wow what ┃a nice module
// I sure hope this shows up when I hover over it
After
1
2
//! 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
1
2
3
fn main() {
(0 == 0).then┃(|| val)
}
After
1
2
3
4
5
6
7
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
1
2
3
4
5
fn main() {
let mut s = String::new();
let closure = |┃a| s.push_str(a);
closure("abc");
}
After
1
2
3
4
5
6
7
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
1
2
3
4
5
6
fn main() {
let x = vec![1, 2, 3];
for┃ v in x {
let y = v * 2;
}
}
After
1
2
3
4
5
6
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
1
2
3
4
5
6
7
8
impl ┃From<usize> for Thing {
fn from(val: usize) -> Self {
Thing {
b: val.to_string(),
a: val
}
}
}
After
1
2
3
4
5
6
7
8
9
10
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
1
2
3
4
5
6
7
fn main() {
if┃ cond {
Some(val)
} else {
None
}
}
After
1
2
3
fn main() {
cond.then(|| val)
}
convert_integer_literal
Source: convert_integer_literal.rs
Converts the base of integer literals to other bases.
Before
1
const _: i32 = 10┃;
After
1
const _: i32 = 0b1010;
convert_into_to_from
Source: convert_into_to_from.rs
Converts an Into impl to an equivalent From impl.
Before
1
2
3
4
5
6
7
8
impl ┃Into<Thing> for usize {
fn into(self) -> Thing {
Thing {
b: self.to_string(),
a: self
}
}
}
After
1
2
3
4
5
6
7
8
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
1
2
3
4
5
6
fn main() {
let iter = iter::repeat((9, 2));
iter.for_each┃(|(x, y)| {
println!("x: {}, y: {}", x, y);
});
}
After
1
2
3
4
5
6
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
1
2
3
fn main() {
let Ok(mut x) = f() else┃ { return };
}
After
1
2
3
4
5
6
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
1
2
3
4
5
6
fn foo(opt: Option<()>) {
let val┃ = match opt {
Some(it) => it,
None => return,
};
}
After
1
2
3
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
4
5
6
7
fn main() {
fn fo┃o(label: &str, number: u64) {
println!("{}: {}", label, number);
}
foo("Bar", 100);
}
After
1
2
3
4
5
6
7
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
1
2
3
4
5
6
fn main() {
┃if cond {
foo();
bar();
}
}
After
1
2
3
4
5
6
7
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
1
2
3
4
5
6
7
fn bar() {
let (a, b, c) = foo();
}
fn foo() -> (┃u32, u32, u32) {
(1, 2, 3)
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
4
5
6
fn main() {
match scrutinee┃ {
Some(val) if val.cond() => true,
_ => false,
}
}
After
1
2
3
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
1
2
3
4
5
fn main() {
┃while cond {
foo();
}
}
After
1
2
3
4
5
6
7
8
fn main() {
loop {
if !cond {
break;
}
foo();
}
}
destructure_struct_binding
Source: destructure_struct_binding.rs
Destructures a struct binding in place.
Before
1
2
3
4
5
6
7
8
9
struct Foo {
bar: i32,
baz: i32,
}
fn main() {
let ┃foo = Foo { bar: 1, baz: 2 };
let bar2 = foo.bar;
let baz2 = &foo.baz;
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
4
fn main() {
let ┃t = (1,2);
let v = t.0;
}
After
1
2
3
4
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
1
2
3
pub as┃ync fn foo() -> usize {
0
}
After
1
2
3
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
1
2
/// Multi-line┃
/// comment
After
1
2
#[doc = r"Multi-line
comment"]
expand_glob_import
Source: expand_glob_import.rs
Expands glob imports.
Before
1
2
3
4
5
6
7
8
mod foo {
pub struct Bar;
pub struct Baz;
}
use foo::*┃;
fn qux(bar: Bar, baz: Baz) {}
After
1
2
3
4
5
6
7
8
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
1
2
3
4
5
6
enum TheEnum┃ {
Foo,
Bar,
Baz = 42,
Quux,
}
After
1
2
3
4
5
6
enum TheEnum {
Foo = 0,
Bar = 1,
Baz = 42,
Quux = 43,
}
extract_expressions_from_format_string
Move an expression out of a format string.
Before
1
2
3
fn main() {
print!("{var} {x + 1}┃");
}
After
1
2
3
fn main() {
print!("{var} {}"┃, x + 1);
}
extract_function
Source: extract_function.rs
Extracts selected statements and comments into new function.
Before
1
2
3
4
5
6
7
fn main() {
let n = 1;
┃let m = n + 2;
// calculate
let k = m + n;┃
let g = 3;
}
After
1
2
3
4
5
6
7
8
9
10
11
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
1
2
3
4
5
6
7
┃fn foo(name: i32) -> i32 {
name + 1
}┃
fn bar(name: i32) -> i32 {
name + 2
}
After
1
2
3
4
5
6
7
8
9
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
1
enum A { ┃One(u32, u32) }
After
1
2
3
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
1
2
3
struct S {
field: ┃(u8, u8, u8)┃,
}
After
1
2
3
4
5
type ┃Type = (u8, u8, u8);
struct S {
field: Type,
}
extract_variable
Source: extract_variable.rs
Extracts subexpression into a variable.
Before
1
2
3
fn main() {
┃(1 + 2)┃ * 4;
}
After
1
2
3
4
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
1
2
3
4
5
struct Bar { y: Y, z: Z }
fn foo(bar: Bar) {
let Bar { ..┃ } = bar;
}
After
1
2
3
4
5
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
1
2
3
4
5
6
mod m {
fn frobnicate() {}
}
fn main() {
m::frobnicate┃();
}
After
1
2
3
4
5
6
mod m {
┃pub(crate) fn frobnicate() {}
}
fn main() {
m::frobnicate();
}
flip_binexpr
Source: flip_binexpr.rs
Flips operands of a binary expression.
Before
1
2
3
fn main() {
let _ = 90 +┃ 2;
}
After
1
2
3
fn main() {
let _ = 2 + 90;
}
flip_comma
Source: flip_comma.rs
Flips two comma-separated items.
Before
1
2
3
fn main() {
((1, 2),┃ (3, 4));
}
After
1
2
3
fn main() {
((3, 4), (1, 2));
}
flip_trait_bound
Source: flip_trait_bound.rs
Flips two trait bounds.
Before
1
fn foo<T: Clone +┃ Copy>() { }
After
1
fn foo<T: Copy + Clone>() { }
generate_constant
Source: generate_constant.rs
Generate a named constant.
Before
1
2
3
4
5
struct S { i: usize }
impl S { pub fn new(n: usize) {} }
fn main() {
let v = S::new(CAPA┃CITY);
}
After
1
2
3
4
5
6
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
1
2
3
4
5
enum Version {
Undefined,
Minor┃,
Major,
}
After
1
2
3
4
5
6
7
8
9
10
11
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
1
2
3
4
5
6
7
struct Example { _inner: () }
impl Example {
pub fn n┃ew() -> Self {
Self { _inner: () }
}
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
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
1
2
3
4
5
6
7
8
9
10
struct Age(u8);
impl Age {
fn age(&self) -> u8 {
self.0
}
}
struct Person {
ag┃e: Age,
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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
1
2
3
4
struct A;
struct B {
┃a: A
}
After
1
2
3
4
5
6
7
8
9
10
11
12
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
1
2
3
4
struct Point {
x: u32,
y: u32,┃
}
After
1
2
3
4
5
#[derive(┃)]
struct Point {
x: u32,
y: u32,
}
generate_doc_example
Generates a rustdoc example when editing an item’s documentation.
Before
1
2
/// Adds two numbers.┃
pub fn add(a: i32, b: i32) -> i32 { a + b }
After
1
2
3
4
5
6
7
8
9
10
/// 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
1
2
3
4
5
6
pub struct S;
impl S {
pub unsafe fn set_len┃(&mut self, len: usize) -> Result<(), std::io::Error> {
/* ... */
}
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
4
enum Value {
Number(i32),
Text(String)┃,
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
1
2
3
4
5
enum Version {
Undefined,
Minor┃,
Major,
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
4
enum Value {
Number(i32),
Text(String)┃,
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
1
2
3
4
5
6
7
enum Countries {
Ghana,
}
fn main() {
let country = Countries::Lesotho┃;
}
After
1
2
3
4
5
6
7
8
enum Countries {
Ghana,
Lesotho,
}
fn main() {
let country = Countries::Lesotho;
}
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
1
enum A { ┃One(u32) }
After
1
2
3
4
5
6
7
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
1
2
3
4
5
struct Baz;
fn baz() -> Baz { Baz }
fn foo() {
bar┃("", baz());
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
struct Person {
nam┃e: String,
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
struct Person {
nam┃e: String,
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
struct Ctx┃<T: Clone> {
data: T,
}
After
1
2
3
4
5
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
1
2
3
4
5
6
7
8
struct MyStruct { data: Vec<String> }
impl MyStruct {
#[must_use]
p┃ub fn len(&self) -> usize {
self.data.len()
}
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
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
1
2
3
4
5
6
7
8
9
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
1
2
3
struct Ctx<T: Clone> {
data: T,┃
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
struct Person {
nam┃e: String,
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
1
2
3
struct ┃Ctx<T: Clone> {
data: T,
}
After
1
2
3
4
5
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
1
2
3
fn foo(name: Option<&str>) {
let name = name.unwrap┃();
}
After
1
2
3
4
5
6
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
1
2
3
4
5
const STRING: &str = "Hello, World!";
fn something() -> &'static str {
STRING┃
}
After
1
2
3
4
5
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
1
2
3
4
5
6
7
8
9
10
fn print(_: &str) {}
fn foo┃(word: &str) {
if !word.is_empty() {
print(word);
}
}
fn bar() {
foo("안녕하세요");
foo("여러분");
}
After
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
1
2
3
4
fn main() {
let x┃ = 1 + 2;
x * 4;
}
After
1
2
3
fn main() {
(1 + 2) * 4;
}
inline_macro
Source: inline_macro.rs
Takes a macro and inlines it one step.
Before
1
2
3
4
5
6
7
8
9
10
11
macro_rules! num {
(+$($t:tt)+) => (1 + num!($($t )+));
(-$($t:tt)+) => (-1 + num!($($t )+));
(+) => (1);
(-) => (-1);
}
fn main() {
let number = num┃!(+ + + - + +);
println!("{number}");
}
After
1
2
3
4
5
6
7
8
9
10
11
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
1
2
3
4
5
type A<T = u32> = Vec<T>;
fn main() {
let a: ┃A;
}
After
1
2
3
4
5
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
1
2
3
4
5
6
7
type ┃A = i32;
fn id(x: A) -> A {
x
};
fn foo() {
let _: A = 3;
}
After
1
2
3
4
5
6
7
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
1
2
3
4
5
6
7
8
9
10
11
12
//- 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
1
2
3
4
5
6
7
8
9
10
11
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
1
fn foo(bar: ┃impl Bar) {}
After
1
fn foo<┃B: Bar>(bar: B) {}
introduce_named_lifetime
Source: introduce_named_lifetime.rs
Change an anonymous lifetime to a named lifetime.
Before
1
2
3
4
5
6
7
impl Cursor<'_┃> {
fn node(self) -> &SyntaxNode {
match self {
Cursor::Replace(node) | Cursor::Before(node) => node,
}
}
}
After
1
2
3
4
5
6
7
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
1
2
3
fn main() {
if┃ !y { A } else { B }
}
After
1
2
3
fn main() {
if y { B } else { A }
}
line_to_block
Source: convert_comment_block.rs
Converts comments between block and single-line form.
Before
1
2
// Multi-line┃
// comment
After
1
2
3
4
/*
Multi-line
comment
*/
make_raw_string
Source: raw_string.rs
Adds r# to a plain string literal.
Before
1
2
3
fn main() {
"Hello,┃ World!";
}
After
1
2
3
fn main() {
r#"Hello, World!"#;
}
make_usual_string
Source: raw_string.rs
Turns a raw string into a plain string.
Before
1
2
3
fn main() {
r#"Hello,┃ "World!""#;
}
After
1
2
3
fn main() {
"Hello, \"World!\"";
}
merge_imports
Source: merge_imports.rs
Merges neighbor imports with a common prefix.
Before
1
2
use std::┃fmt::Formatter;
use std::io;
After
1
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
1
2
3
4
5
6
7
8
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
match action {
┃Action::Move(..) => foo(),
Action::Stop => foo(),
}
}
After
1
2
3
4
5
6
7
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
1
2
3
fn main() {
i┃f x == 3 { if y == 4 { 1 } }
}
After
1
2
3
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
1
2
3
4
5
6
7
8
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
match action {
Action::Move { distance } => ┃if distance > 10 { foo() },
_ => (),
}
}
After
1
2
3
4
5
6
7
8
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
1
2
3
fn apply<T, U, ┃F: FnOnce(T) -> U>(f: F, x: T) -> U {
f(x)
}
After
1
2
3
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
1
2
3
4
5
6
7
8
9
struct S;
impl S {
fn foo() -> usize {
/// The answer.
const C┃: usize = 42;
C * C
}
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
4
//- /main.rs
mod a;
//- /a/mod.rs
┃fn t() {}┃
After
1
fn t() {}
move_guard_to_arm_body
Source: move_guard.rs
Moves match guard into match arm body.
Before
1
2
3
4
5
6
7
8
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
match action {
Action::Move { distance } ┃if distance > 10 => foo(),
_ => (),
}
}
After
1
2
3
4
5
6
7
8
9
10
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
1
2
3
mod ┃foo {
fn t() {}
}
After
1
mod foo;
move_to_mod_rs
Source: move_to_mod_rs.rs
Moves xxx.rs to xxx/mod.rs.
Before
1
2
3
4
//- /main.rs
mod a;
//- /a.rs
┃fn t() {}┃
After
1
fn t() {}
normalize_import
Source: normalize_import.rs
Normalizes an import.
Before
1
use┃ std::{io, {fmt::Formatter}};
After
1
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
1
2
3
4
5
6
7
8
9
fn main() {
let foo┃ = true;
if foo {
println!("It's true");
} else {
println!("It's false");
}
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
4
5
6
7
8
9
fn main() {
let mut foo = 6;
if true {
┃foo = 5;
} else {
foo = 4;
}
}
After
1
2
3
4
5
6
7
8
9
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
1
2
3
4
5
6
7
8
struct Foo;
impl Foo {
fn foo(&self) {}
}
fn main() {
let foo = Foo;
foo.fo┃o();
}
After
1
2
3
4
5
6
7
8
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
1
2
3
fn main() {
let map = HashMap┃::new();
}
After
1
2
3
fn main() {
let map = std::collections::HashMap::new();
}
reformat_number_literal
Source: number_representation.rs
Adds or removes separators from integer literal.
Before
1
const _: i32 = 1012345┃;
After
1
const _: i32 = 1_012_345;
remove_dbg
Source: remove_dbg.rs
Removes dbg!() macro call.
Before
1
2
3
fn main() {
let x = ┃dbg!(42 * dbg!(4 + 2));┃
}
After
1
2
3
fn main() {
let x = 42 * (4 + 2);
}
remove_hash
Source: raw_string.rs
Removes a hash from a raw string literal.
Before
1
2
3
fn main() {
r#"Hello,┃ World!"#;
}
After
1
2
3
fn main() {
r"Hello, World!";
}
remove_mut
Source: remove_mut.rs
Removes the mut keyword.
Before
1
2
3
impl Walrus {
fn feed(&mut┃ self, amount: u32) {}
}
After
1
2
3
impl Walrus {
fn feed(&self, amount: u32) {}
}
remove_parentheses
Source: remove_parentheses.rs
Removes redundant parentheses.
Before
1
2
3
fn main() {
_ = ┃(2) + 2;
}
After
1
2
3
fn main() {
_ = 2 + 2;
}
remove_unused_imports
Source: remove_unused_imports.rs
Removes any use statements in the current selection that are unused.
Before
1
2
3
4
struct X();
mod foo {
use super::X┃;
}
After
1
2
3
struct X();
mod foo {
}
remove_unused_param
Source: remove_unused_param.rs
Removes unused function parameter.
Before
1
2
3
4
5
fn frobnicate(x: i32┃) {}
fn main() {
frobnicate(92);
}
After
1
2
3
4
5
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
1
2
struct Foo {foo: i32, bar: i32};
const test: Foo = ┃Foo {bar: 0, foo: 1}
After
1
2
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
1
2
3
4
5
6
7
8
9
10
11
12
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
1
2
3
4
5
6
7
8
9
10
11
12
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
1
2
3
fn main() {
let x = 1 ┃+ 2;
}
After
1
2
3
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
1
2
3
fn main() {
let x = 1 ┃+ 2;
}
After
1
2
3
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
1
2
3
fn main() {
let x = 1 ┃+ 2;
}
After
1
2
3
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
1
2
3
fn main() {
find('{┃');
}
After
1
2
3
fn main() {
find("{");
}
replace_derive_with_manual_impl
Converts a derive impl into a manual one.
Before
1
2
#[derive(Deb┃ug, Display)]
struct S;
After
1
2
3
4
5
6
7
8
#[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
1
2
3
4
5
6
7
8
9
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
┃if let Action::Move { distance } = action {
foo(distance)
} else {
bar()
}
}
After
1
2
3
4
5
6
7
8
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
1
2
3
4
fn main() {
let x = Some(1);
if x.is_som┃e() {}
}
After
1
2
3
4
fn main() {
let x = Some(1);
if let Some(${0:x}) = x {}
}
replace_let_with_if_let
Source: replace_let_with_if_let.rs
Replaces let with an if let.
Before
1
2
3
4
5
6
fn main(action: Action) {
┃let x = compute();
}
fn compute() -> Option<i32> { None }
After
1
2
3
4
5
6
7
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
1
2
3
4
5
6
7
8
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
┃match action {
Action::Move { distance } => foo(distance),
_ => bar(),
}
}
After
1
2
3
4
5
6
7
8
9
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
1
fn new<P┃: AsRef<Path>>(location: P) -> Self {}
After
1
fn new(location: impl AsRef<Path>) -> Self {}
replace_qualified_name_with_use
Adds a use statement for a given fully-qualified name.
Before
1
fn process(map: std::collections::┃HashMap<String, String>) {}
After
1
2
3
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
1
2
3
fn main() {
find("{┃");
}
After
1
2
3
fn main() {
find('{');
}
replace_try_expr_with_match
Source: replace_try_expr_with_match.rs
Replaces a try expression with a match expression.
Before
1
2
3
fn handle() {
let pat = Some(true)┃?;
}
After
1
2
3
4
5
6
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
1
2
3
4
fn make<T>() -> T { ) }
fn main() {
let a = make┃::<i32>();
}
After
1
2
3
4
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
1
2
3
4
fn foo() {
let a = Some(1);
a.unwra┃p_or_else(|| 2);
}
After
1
2
3
4
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
1
2
3
4
fn foo() {
let a = Some(1);
a.unwra┃p_or(2);
}
After
1
2
3
4
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
1
struct ┃Foo┃ { second: u32, first: String }
After
1
struct Foo { first: String, second: u32 }
Before
1
2
3
4
trait ┃Bar┃ {
fn second(&self) -> u32;
fn first(&self) -> String;
}
After
1
2
3
4
trait Bar {
fn first(&self) -> String;
fn second(&self) -> u32;
}
Before
1
2
3
4
5
struct Baz;
impl ┃Baz┃ {
fn second(&self) -> u32;
fn first(&self) -> String;
}
After
1
2
3
4
5
struct Baz;
impl Baz {
fn first(&self) -> String;
fn second(&self) -> u32;
}
There is a difference between sorting enum variants:
Before
1
2
3
4
enum ┃Animal┃ {
Dog(String, f64),
Cat { weight: f64, name: String },
}
After
1
2
3
4
enum Animal {
Cat { weight: f64, name: String },
Dog(String, f64),
}
and sorting a single enum struct variant:
Before
1
2
3
4
enum Animal {
Dog(String, f64),
Cat ┃{ weight: f64, name: String }┃,
}
After
1
2
3
4
enum Animal {
Dog(String, f64),
Cat { name: String, weight: f64 },
}
split_import
Source: split_import.rs
Wraps the tail of import into braces.
Before
1
use std::┃collections::HashMap;
After
1
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
1
2
3
pub fn foo() -> impl core::future::F┃uture<Output = usize> {
async { 0 }
}
After
1
2
3
pub async fn foo() -> usize {
async { 0 }
}
toggle_ignore
Source: toggle_ignore.rs
Adds #[ignore] attribute to the test.
Before
1
2
3
4
┃#[test]
fn arithmetics {
assert_eq!(2 + 2, 5);
}
After
1
2
3
4
5
#[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
1
2
3
4
5
macro_rules! sth {
() => {};
}
sth!┃( );
After
1
2
3
4
5
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
1
2
3
4
5
6
7
enum Action { Move { distance: u32 }, Stop }
fn handle(action: Action) {
match action {
Action::Move(..) ┃| Action::Stop => foo(),
}
}
After
1
2
3
4
5
6
7
8
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
1
use std::fmt::{Debug, Display┃};
After
1
2
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
1
2
pub async f┃n foo() {}
pub async fn bar() { foo().await }
After
1
2
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
1
2
3
fn main() {
std::ops::Add::add┃(1, 2);
}
After
1
2
3
4
5
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
1
2
3
4
5
fn foo() {
if true {┃
println!("foo");
}
}
After
1
2
3
fn foo() {
println!("foo");
}
unwrap_result_return_type
Source: unwrap_result_return_type.rs
Unwrap the function’s return type.
Before
1
fn foo() -> Result<i32>┃ { Ok(42i32) }
After
1
fn foo() -> i32 { 42i32 }
unwrap_tuple
Source: unwrap_tuple.rs
Unwrap the tuple to different variables.
Before
1
2
3
fn main() {
┃let (foo, bar) = ("Foo", "Bar");
}
After
1
2
3
4
fn main() {
let foo = "Foo";
let bar = "Bar";
}
wrap_return_type_in_result
Source: wrap_return_type_in_result.rs
Wrap the function’s return type into Result.
Before
1
fn foo() -> i32┃ { 42i32 }
After
1
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
1
2
3
4
#[derive┃(Debug)]
struct S {
field: i32
}
After
1
2
3
4
#[cfg_attr(┃, derive(Debug))]
struct S {
field: i32
}