1016 lines
18 KiB
Plaintext
1016 lines
18 KiB
Plaintext
[discrete]
|
|
=== `add_custom_impl`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_custom_impl.rs#L14[add_custom_impl.rs]
|
|
|
|
Adds impl block for derived trait.
|
|
|
|
.Before
|
|
```rust
|
|
#[derive(Deb┃ug, Display)]
|
|
struct S;
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
#[derive(Display)]
|
|
struct S;
|
|
|
|
impl Debug for S {
|
|
$0
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_derive`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_derive.rs#L9[add_derive.rs]
|
|
|
|
Adds a new `#[derive()]` clause to a struct or enum.
|
|
|
|
.Before
|
|
```rust
|
|
struct Point {
|
|
x: u32,
|
|
y: u32,┃
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
#[derive($0)]
|
|
struct Point {
|
|
x: u32,
|
|
y: u32,
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_explicit_type`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_explicit_type.rs#L9[add_explicit_type.rs]
|
|
|
|
Specify type for a let binding.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
let x┃ = 92;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
let x: i32 = 92;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_from_impl_for_enum`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs#L7[add_from_impl_for_enum.rs]
|
|
|
|
Adds a From impl for an enum variant with one tuple field.
|
|
|
|
.Before
|
|
```rust
|
|
enum A { ┃One(u32) }
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum A { One(u32) }
|
|
|
|
impl From<u32> for A {
|
|
fn from(v: u32) -> Self {
|
|
A::One(v)
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_function`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_function.rs#L19[add_function.rs]
|
|
|
|
Adds a stub function with a signature matching the function under the cursor.
|
|
|
|
.Before
|
|
```rust
|
|
struct Baz;
|
|
fn baz() -> Baz { Baz }
|
|
fn foo() {
|
|
bar┃("", baz());
|
|
}
|
|
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
struct Baz;
|
|
fn baz() -> Baz { Baz }
|
|
fn foo() {
|
|
bar("", baz());
|
|
}
|
|
|
|
fn bar(arg: &str, baz: Baz) {
|
|
${0:todo!()}
|
|
}
|
|
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_hash`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L65[raw_string.rs]
|
|
|
|
Adds a hash to a raw string literal.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
r#"Hello,┃ World!"#;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
r##"Hello, World!"##;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_impl`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_impl.rs#L6[add_impl.rs]
|
|
|
|
Adds a new inherent impl for a type.
|
|
|
|
.Before
|
|
```rust
|
|
struct Ctx<T: Clone> {
|
|
data: T,┃
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
struct Ctx<T: Clone> {
|
|
data: T,
|
|
}
|
|
|
|
impl<T: Clone> Ctx<T> {
|
|
$0
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_impl_default_members`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_missing_impl_members.rs#L64[add_missing_impl_members.rs]
|
|
|
|
Adds scaffold for overriding default impl members.
|
|
|
|
.Before
|
|
```rust
|
|
trait Trait {
|
|
Type X;
|
|
fn foo(&self);
|
|
fn bar(&self) {}
|
|
}
|
|
|
|
impl Trait for () {
|
|
Type X = ();
|
|
fn foo(&self) {}┃
|
|
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
trait Trait {
|
|
Type X;
|
|
fn foo(&self);
|
|
fn bar(&self) {}
|
|
}
|
|
|
|
impl Trait for () {
|
|
Type X = ();
|
|
fn foo(&self) {}
|
|
$0fn bar(&self) {}
|
|
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_impl_missing_members`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_missing_impl_members.rs#L24[add_missing_impl_members.rs]
|
|
|
|
Adds scaffold for required impl members.
|
|
|
|
.Before
|
|
```rust
|
|
trait Trait<T> {
|
|
Type X;
|
|
fn foo(&self) -> T;
|
|
fn bar(&self) {}
|
|
}
|
|
|
|
impl Trait<u32> for () {┃
|
|
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
trait Trait<T> {
|
|
Type X;
|
|
fn foo(&self) -> T;
|
|
fn bar(&self) {}
|
|
}
|
|
|
|
impl Trait<u32> for () {
|
|
fn foo(&self) -> u32 {
|
|
${0:todo!()}
|
|
}
|
|
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_new`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_new.rs#L12[add_new.rs]
|
|
|
|
Adds a new inherent impl for a type.
|
|
|
|
.Before
|
|
```rust
|
|
struct Ctx<T: Clone> {
|
|
data: T,┃
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
struct Ctx<T: Clone> {
|
|
data: T,
|
|
}
|
|
|
|
impl<T: Clone> Ctx<T> {
|
|
fn $0new(data: T) -> Self { Self { data } }
|
|
}
|
|
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `add_turbo_fish`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/add_turbo_fish.rs#L10[add_turbo_fish.rs]
|
|
|
|
Adds `::<_>` to a call of a generic method or function.
|
|
|
|
.Before
|
|
```rust
|
|
fn make<T>() -> T { todo!() }
|
|
fn main() {
|
|
let x = make┃();
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn make<T>() -> T { todo!() }
|
|
fn main() {
|
|
let x = make::<${0:_}>();
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `apply_demorgan`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/apply_demorgan.rs#L5[apply_demorgan.rs]
|
|
|
|
Apply [De Morgan's law](https://en.wikipedia.org/wiki/De_Morgan%27s_laws).
|
|
This transforms expressions of the form `!l || !r` into `!(l && r)`.
|
|
This also works with `&&`. This assist can only be applied with the cursor
|
|
on either `||` or `&&`, with both operands being a negation of some kind.
|
|
This means something of the form `!x` or `x != y`.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
if x != 4 ||┃ !y {}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
if !(x == 4 && y) {}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `auto_import`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/auto_import.rs#L18[auto_import.rs]
|
|
|
|
If the name is unresolved, provides all possible imports for it.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
let map = HashMap┃::new();
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
use std::collections::HashMap;
|
|
|
|
fn main() {
|
|
let map = HashMap::new();
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `change_return_type_to_result`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/change_return_type_to_result.rs#L8[change_return_type_to_result.rs]
|
|
|
|
Change the function's return type to Result.
|
|
|
|
.Before
|
|
```rust
|
|
fn foo() -> i32┃ { 42i32 }
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `change_visibility`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/change_visibility.rs#L14[change_visibility.rs]
|
|
|
|
Adds or changes existing visibility specifier.
|
|
|
|
.Before
|
|
```rust
|
|
┃fn frobnicate() {}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
pub(crate) fn frobnicate() {}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `convert_to_guarded_return`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/early_return.rs#L21[early_return.rs]
|
|
|
|
Replace a large conditional with a guarded return.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
┃if cond {
|
|
foo();
|
|
bar();
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
if !cond {
|
|
return;
|
|
}
|
|
foo();
|
|
bar();
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `fill_match_arms`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/fill_match_arms.rs#L14[fill_match_arms.rs]
|
|
|
|
Adds missing clauses to a `match` expression.
|
|
|
|
.Before
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
┃
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
$0Action::Move { distance } => {}
|
|
Action::Stop => {}
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `fix_visibility`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/fix_visibility.rs#L13[fix_visibility.rs]
|
|
|
|
Makes inaccessible item public.
|
|
|
|
.Before
|
|
```rust
|
|
mod m {
|
|
fn frobnicate() {}
|
|
}
|
|
fn main() {
|
|
m::frobnicate┃() {}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
mod m {
|
|
$0pub(crate) fn frobnicate() {}
|
|
}
|
|
fn main() {
|
|
m::frobnicate() {}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `flip_binexpr`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/flip_binexpr.rs#L5[flip_binexpr.rs]
|
|
|
|
Flips operands of a binary expression.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
let _ = 90 +┃ 2;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
let _ = 2 + 90;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `flip_comma`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/flip_comma.rs#L5[flip_comma.rs]
|
|
|
|
Flips two comma-separated items.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
((1, 2),┃ (3, 4));
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
((3, 4), (1, 2));
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `flip_trait_bound`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/flip_trait_bound.rs#L9[flip_trait_bound.rs]
|
|
|
|
Flips two trait bounds.
|
|
|
|
.Before
|
|
```rust
|
|
fn foo<T: Clone +┃ Copy>() { }
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn foo<T: Copy + Clone>() { }
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `inline_local_variable`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/inline_local_variable.rs#L13[inline_local_variable.rs]
|
|
|
|
Inlines local variable.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
let x┃ = 1 + 2;
|
|
x * 4;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
(1 + 2) * 4;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `introduce_named_lifetime`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/introduce_named_lifetime.rs#L12[introduce_named_lifetime.rs]
|
|
|
|
Change an anonymous lifetime to a named lifetime.
|
|
|
|
.Before
|
|
```rust
|
|
impl Cursor<'_┃> {
|
|
fn node(self) -> &SyntaxNode {
|
|
match self {
|
|
Cursor::Replace(node) | Cursor::Before(node) => node,
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
impl<'a> Cursor<'a> {
|
|
fn node(self) -> &SyntaxNode {
|
|
match self {
|
|
Cursor::Replace(node) | Cursor::Before(node) => node,
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `introduce_variable`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/introduce_variable.rs#L14[introduce_variable.rs]
|
|
|
|
Extracts subexpression into a variable.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
┃(1 + 2)┃ * 4;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
let $0var_name = (1 + 2);
|
|
var_name * 4;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `invert_if`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/invert_if.rs#L12[invert_if.rs]
|
|
|
|
Apply invert_if
|
|
This transforms if expressions of the form `if !x {A} else {B}` into `if x {B} else {A}`
|
|
This also works with `!=`. This assist can only be applied with the cursor
|
|
on `if`.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
if┃ !y { A } else { B }
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
if y { B } else { A }
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `make_raw_string`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L10[raw_string.rs]
|
|
|
|
Adds `r#` to a plain string literal.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
"Hello,┃ World!";
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
r#"Hello, World!"#;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `make_usual_string`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L39[raw_string.rs]
|
|
|
|
Turns a raw string into a plain string.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
r#"Hello,┃ "World!""#;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
"Hello, \"World!\"";
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `merge_imports`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/merge_imports.rs#L14[merge_imports.rs]
|
|
|
|
Merges two imports with a common prefix.
|
|
|
|
.Before
|
|
```rust
|
|
use std::┃fmt::Formatter;
|
|
use std::io;
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
use std::{fmt::Formatter, io};
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `merge_match_arms`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/merge_match_arms.rs#L11[merge_match_arms.rs]
|
|
|
|
Merges identical match arms.
|
|
|
|
.Before
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
┃Action::Move(..) => foo(),
|
|
Action::Stop => foo(),
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
Action::Move(..) | Action::Stop => foo(),
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `move_arm_cond_to_match_guard`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/move_guard.rs#L56[move_guard.rs]
|
|
|
|
Moves if expression from match arm body into a guard.
|
|
|
|
.Before
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
Action::Move { distance } => ┃if distance > 10 { foo() },
|
|
_ => (),
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
Action::Move { distance } if distance > 10 => foo(),
|
|
_ => (),
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `move_bounds_to_where_clause`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/move_bounds.rs#L10[move_bounds.rs]
|
|
|
|
Moves inline type bounds to a where clause.
|
|
|
|
.Before
|
|
```rust
|
|
fn apply<T, U, ┃F: FnOnce(T) -> U>(f: F, x: T) -> U {
|
|
f(x)
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U {
|
|
f(x)
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `move_guard_to_arm_body`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/move_guard.rs#L8[move_guard.rs]
|
|
|
|
Moves match guard into match arm body.
|
|
|
|
.Before
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
Action::Move { distance } ┃if distance > 10 => foo(),
|
|
_ => (),
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
Action::Move { distance } => if distance > 10 { foo() },
|
|
_ => (),
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `remove_dbg`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/remove_dbg.rs#L8[remove_dbg.rs]
|
|
|
|
Removes `dbg!()` macro call.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
┃dbg!(92);
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
92;
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `remove_hash`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/raw_string.rs#L89[raw_string.rs]
|
|
|
|
Removes a hash from a raw string literal.
|
|
|
|
.Before
|
|
```rust
|
|
fn main() {
|
|
r#"Hello,┃ World!"#;
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn main() {
|
|
r"Hello, World!";
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `remove_mut`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/remove_mut.rs#L5[remove_mut.rs]
|
|
|
|
Removes the `mut` keyword.
|
|
|
|
.Before
|
|
```rust
|
|
impl Walrus {
|
|
fn feed(&mut┃ self, amount: u32) {}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
impl Walrus {
|
|
fn feed(&self, amount: u32) {}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `reorder_fields`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/reorder_fields.rs#L10[reorder_fields.rs]
|
|
|
|
Reorder the fields of record literals and record patterns in the same order as in
|
|
the definition.
|
|
|
|
.Before
|
|
```rust
|
|
struct Foo {foo: i32, bar: i32};
|
|
const test: Foo = ┃Foo {bar: 0, foo: 1}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
struct Foo {foo: i32, bar: i32};
|
|
const test: Foo = Foo {foo: 1, bar: 0}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `replace_if_let_with_match`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_if_let_with_match.rs#L13[replace_if_let_with_match.rs]
|
|
|
|
Replaces `if let` with an else branch with a `match` expression.
|
|
|
|
.Before
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
┃if let Action::Move { distance } = action {
|
|
foo(distance)
|
|
} else {
|
|
bar()
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum Action { Move { distance: u32 }, Stop }
|
|
|
|
fn handle(action: Action) {
|
|
match action {
|
|
Action::Move { distance } => foo(distance),
|
|
_ => bar(),
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `replace_let_with_if_let`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_let_with_if_let.rs#L14[replace_let_with_if_let.rs]
|
|
|
|
Replaces `let` with an `if-let`.
|
|
|
|
.Before
|
|
```rust
|
|
|
|
fn main(action: Action) {
|
|
┃let x = compute();
|
|
}
|
|
|
|
fn compute() -> Option<i32> { None }
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
|
|
fn main(action: Action) {
|
|
if let Some(x) = compute() {
|
|
}
|
|
}
|
|
|
|
fn compute() -> Option<i32> { None }
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `replace_qualified_name_with_use`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs#L6[replace_qualified_name_with_use.rs]
|
|
|
|
Adds a use statement for a given fully-qualified name.
|
|
|
|
.Before
|
|
```rust
|
|
fn process(map: std::collections::┃HashMap<String, String>) {}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
use std::collections::HashMap;
|
|
|
|
fn process(map: HashMap<String, String>) {}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `replace_unwrap_with_match`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/replace_unwrap_with_match.rs#L17[replace_unwrap_with_match.rs]
|
|
|
|
Replaces `unwrap` a `match` expression. Works for Result and Option.
|
|
|
|
.Before
|
|
```rust
|
|
enum Result<T, E> { Ok(T), Err(E) }
|
|
fn main() {
|
|
let x: Result<i32, i32> = Result::Ok(92);
|
|
let y = x.┃unwrap();
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
enum Result<T, E> { Ok(T), Err(E) }
|
|
fn main() {
|
|
let x: Result<i32, i32> = Result::Ok(92);
|
|
let y = match x {
|
|
Ok(a) => a,
|
|
$0_ => unreachable!(),
|
|
};
|
|
}
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `split_import`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/split_import.rs#L7[split_import.rs]
|
|
|
|
Wraps the tail of import into braces.
|
|
|
|
.Before
|
|
```rust
|
|
use std::┃collections::HashMap;
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
use std::{collections::HashMap};
|
|
```
|
|
|
|
|
|
[discrete]
|
|
=== `unwrap_block`
|
|
**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/ra_assists/src/handlers/unwrap_block.rs#L9[unwrap_block.rs]
|
|
|
|
This assist removes if...else, for, while and loop control statements to just keep the body.
|
|
|
|
.Before
|
|
```rust
|
|
fn foo() {
|
|
if true {┃
|
|
println!("foo");
|
|
}
|
|
}
|
|
```
|
|
|
|
.After
|
|
```rust
|
|
fn foo() {
|
|
println!("foo");
|
|
}
|
|
```
|