156 lines
3.0 KiB
Rust
156 lines
3.0 KiB
Rust
use syntax::{
|
|
ast::{self, edit::AstNodeEdit, make},
|
|
AstNode,
|
|
};
|
|
|
|
use crate::{AssistContext, AssistId, AssistKind, Assists};
|
|
|
|
// Assist: add_braces
|
|
//
|
|
// Adds braces to lambda and match arm expressions.
|
|
//
|
|
// ```
|
|
// fn foo(n: i32) -> i32 {
|
|
// match n {
|
|
// 1 =>$0 n + 1,
|
|
// _ => 0
|
|
// }
|
|
// }
|
|
// ```
|
|
// ->
|
|
// ```
|
|
// fn foo(n: i32) -> i32 {
|
|
// match n {
|
|
// 1 => {
|
|
// n + 1
|
|
// },
|
|
// _ => 0
|
|
// }
|
|
// }
|
|
// ```
|
|
pub(crate) fn add_braces(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
|
|
let (expr_type, expr) = get_replacement_node(ctx)?;
|
|
|
|
acc.add(
|
|
AssistId("add_braces", AssistKind::RefactorRewrite),
|
|
match expr_type {
|
|
ParentType::ClosureExpr => "Add braces to closure body",
|
|
ParentType::MatchArmExpr => "Add braces to arm expression",
|
|
},
|
|
expr.syntax().text_range(),
|
|
|builder| {
|
|
let block_expr = AstNodeEdit::indent(
|
|
&make::block_expr(None, Some(expr.clone())),
|
|
AstNodeEdit::indent_level(&expr),
|
|
);
|
|
|
|
builder.replace(expr.syntax().text_range(), block_expr.syntax().text());
|
|
},
|
|
)
|
|
}
|
|
|
|
enum ParentType {
|
|
MatchArmExpr,
|
|
ClosureExpr,
|
|
}
|
|
|
|
fn get_replacement_node(ctx: &AssistContext<'_>) -> Option<(ParentType, ast::Expr)> {
|
|
if let Some(match_arm) = ctx.find_node_at_offset::<ast::MatchArm>() {
|
|
let match_arm_expr = match_arm.expr()?;
|
|
|
|
if matches!(match_arm_expr, ast::Expr::BlockExpr(_)) {
|
|
return None;
|
|
}
|
|
|
|
return Some((ParentType::MatchArmExpr, match_arm_expr));
|
|
} else if let Some(closure_expr) = ctx.find_node_at_offset::<ast::ClosureExpr>() {
|
|
let body = closure_expr.body()?;
|
|
|
|
if matches!(body, ast::Expr::BlockExpr(_)) {
|
|
return None;
|
|
}
|
|
|
|
return Some((ParentType::ClosureExpr, body));
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::tests::{check_assist, check_assist_not_applicable};
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn suggest_add_braces_for_closure() {
|
|
check_assist(
|
|
add_braces,
|
|
r#"
|
|
fn foo() {
|
|
t(|n|$0 n + 100);
|
|
}
|
|
"#,
|
|
r#"
|
|
fn foo() {
|
|
t(|n| {
|
|
n + 100
|
|
});
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_assist_for_closures_with_braces() {
|
|
check_assist_not_applicable(
|
|
add_braces,
|
|
r#"
|
|
fn foo() {
|
|
t(|n|$0 { n + 100 });
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn suggest_add_braces_for_match() {
|
|
check_assist(
|
|
add_braces,
|
|
r#"
|
|
fn foo() {
|
|
match n {
|
|
Some(n) $0=> 29,
|
|
_ => ()
|
|
};
|
|
}
|
|
"#,
|
|
r#"
|
|
fn foo() {
|
|
match n {
|
|
Some(n) => {
|
|
29
|
|
},
|
|
_ => ()
|
|
};
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_assist_for_match_with_braces() {
|
|
check_assist_not_applicable(
|
|
add_braces,
|
|
r#"
|
|
fn foo() {
|
|
match n {
|
|
Some(n) $0=> { return 29; },
|
|
_ => ()
|
|
};
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
}
|