rust/crates/ra_assists/src/assists/fill_match_arms.rs

258 lines
6.3 KiB
Rust
Raw Normal View History

//! FIXME: write short doc here
2019-08-22 13:31:21 -05:00
use std::iter;
2019-02-03 12:26:35 -06:00
2019-09-12 16:34:52 -05:00
use hir::{db::HirDatabase, Adt, HasSource};
2019-10-12 14:07:47 -05:00
use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
2019-02-03 12:26:35 -06:00
2019-09-26 04:18:26 -05:00
use crate::{Assist, AssistCtx, AssistId};
2019-06-23 23:05:50 -05:00
2019-10-26 09:37:04 -05:00
// Assist: fill_match_arms
//
// Adds missing clauses to a `match` expression.
//
// ```
// enum Action { Move { distance: u32 }, Stop }
//
// fn handle(action: Action) {
// match action {
// <|>
// }
// }
// ```
// ->
// ```
// enum Action { Move { distance: u32 }, Stop }
//
// fn handle(action: Action) {
// match action {
2019-10-26 10:03:55 -05:00
// Action::Move { distance } => (),
2019-10-26 09:37:04 -05:00
// Action::Stop => (),
// }
// }
// ```
pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
2019-02-03 12:26:35 -06:00
let match_expr = ctx.node_at_offset::<ast::MatchExpr>()?;
2019-08-22 13:31:21 -05:00
let match_arm_list = match_expr.match_arm_list()?;
2019-02-03 12:26:35 -06:00
// We already have some match arms, so we don't provide any assists.
2019-06-23 23:05:50 -05:00
// Unless if there is only one trivial match arm possibly created
// by match postfix complete. Trivial match arm is the catch all arm.
2019-08-22 13:31:21 -05:00
let mut existing_arms = match_arm_list.arms();
if let Some(arm) = existing_arms.next() {
if !is_trivial(&arm) || existing_arms.next().is_some() {
return None;
2019-02-03 12:26:35 -06:00
}
2019-07-04 21:59:28 -05:00
};
2019-02-03 12:26:35 -06:00
let expr = match_expr.expr()?;
2019-08-22 13:31:21 -05:00
let enum_def = {
let file_id = ctx.frange.file_id;
let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, expr.syntax(), None);
resolve_enum_def(ctx.db, &analyzer, &expr)?
};
let variant_list = enum_def.variant_list()?;
2019-02-03 12:26:35 -06:00
2019-02-24 04:53:35 -06:00
ctx.add_action(AssistId("fill_match_arms"), "fill match arms", |edit| {
2019-10-12 14:07:47 -05:00
let indent_level = IndentLevel::from_node(match_arm_list.syntax());
let new_arm_list = {
let variants = variant_list.variants();
let arms = variants
.filter_map(build_pat)
.map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
indent_level.increase_indent(make::match_arm_list(arms))
};
2019-02-03 12:26:35 -06:00
2019-07-20 04:58:27 -05:00
edit.target(match_expr.syntax().text_range());
edit.set_cursor(expr.syntax().text_range().start());
2019-10-12 14:07:47 -05:00
edit.replace_ast(match_arm_list, new_arm_list);
});
ctx.build()
2019-02-03 12:26:35 -06:00
}
2019-08-22 13:31:21 -05:00
fn is_trivial(arm: &ast::MatchArm) -> bool {
arm.pats().any(|pat| match pat {
ast::Pat::PlaceholderPat(..) => true,
_ => false,
})
}
fn resolve_enum_def(
db: &impl HirDatabase,
analyzer: &hir::SourceAnalyzer,
expr: &ast::Expr,
) -> Option<ast::EnumDef> {
let expr_ty = analyzer.type_of(db, &expr)?;
analyzer.autoderef(db, expr_ty).find_map(|ty| match ty.as_adt() {
2019-09-12 16:34:52 -05:00
Some((Adt::Enum(e), _)) => Some(e.source(db).ast),
2019-08-22 13:31:21 -05:00
_ => None,
})
}
fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
2019-09-26 04:18:26 -05:00
let path = make::path_qualified(
make::path_from_name_ref(make::name_ref(&var.parent_enum().name()?.syntax().to_string())),
make::name_ref(&var.name()?.syntax().to_string()),
);
2019-08-22 13:31:21 -05:00
let pat: ast::Pat = match var.kind() {
ast::StructKind::Tuple(field_list) => {
2019-09-26 04:18:26 -05:00
let pats =
iter::repeat(make::placeholder_pat().into()).take(field_list.fields().count());
make::tuple_struct_pat(path, pats).into()
2019-08-22 13:31:21 -05:00
}
ast::StructKind::Named(field_list) => {
2019-09-26 04:18:26 -05:00
let pats = field_list.fields().map(|f| make::bind_pat(f.name().unwrap()).into());
make::record_pat(path, pats).into()
2019-08-22 13:31:21 -05:00
}
2019-09-26 04:18:26 -05:00
ast::StructKind::Unit => make::path_pat(path).into(),
2019-08-22 13:31:21 -05:00
};
Some(pat)
}
2019-02-03 12:26:35 -06:00
#[cfg(test)]
mod tests {
2019-02-08 17:34:05 -06:00
use crate::helpers::{check_assist, check_assist_target};
2019-02-03 12:26:35 -06:00
use super::fill_match_arms;
#[test]
fn fill_match_arms_empty_body() {
check_assist(
fill_match_arms,
r#"
enum A {
As,
Bs,
Cs(String),
Ds(String, String),
2019-08-22 13:31:21 -05:00
Es{ x: usize, y: usize }
2019-02-03 12:26:35 -06:00
}
fn main() {
let a = A::As;
match a<|> {}
}
"#,
r#"
enum A {
As,
Bs,
Cs(String),
Ds(String, String),
2019-08-22 13:31:21 -05:00
Es{ x: usize, y: usize }
2019-02-03 12:26:35 -06:00
}
fn main() {
let a = A::As;
match <|>a {
A::As => (),
A::Bs => (),
A::Cs(_) => (),
A::Ds(_, _) => (),
2019-10-26 10:03:55 -05:00
A::Es { x, y } => (),
2019-02-03 12:26:35 -06:00
}
}
"#,
);
}
#[test]
fn test_fill_match_arm_refs() {
check_assist(
fill_match_arms,
r#"
enum A {
As,
}
fn foo(a: &A) {
match a<|> {
}
}
"#,
r#"
enum A {
As,
}
fn foo(a: &A) {
match <|>a {
A::As => (),
}
}
"#,
);
check_assist(
fill_match_arms,
r#"
enum A {
2019-08-22 13:31:21 -05:00
Es{ x: usize, y: usize }
}
fn foo(a: &mut A) {
match a<|> {
}
}
"#,
r#"
enum A {
2019-08-22 13:31:21 -05:00
Es{ x: usize, y: usize }
}
fn foo(a: &mut A) {
match <|>a {
2019-10-26 10:03:55 -05:00
A::Es { x, y } => (),
2019-02-03 12:26:35 -06:00
}
}
"#,
);
}
2019-02-08 17:34:05 -06:00
#[test]
fn fill_match_arms_target() {
check_assist_target(
fill_match_arms,
r#"
2019-08-22 13:31:21 -05:00
enum E { X, Y }
2019-02-08 17:34:05 -06:00
fn main() {
match E::X<|> {}
}
"#,
"match E::X {}",
);
}
2019-06-23 23:05:50 -05:00
#[test]
fn fill_match_arms_trivial_arm() {
check_assist(
fill_match_arms,
r#"
enum E { X, Y }
fn main() {
match E::X {
<|>_ => {},
}
}
"#,
r#"
enum E { X, Y }
fn main() {
match <|>E::X {
E::X => (),
E::Y => (),
}
}
"#,
);
}
2019-02-03 12:26:35 -06:00
}