165 lines
3.5 KiB
Rust
165 lines
3.5 KiB
Rust
use ide_db::defs::{classify_name_ref, Definition, NameRefClass};
|
|
use syntax::{ast, AstNode, SyntaxKind, T};
|
|
use test_utils::mark;
|
|
|
|
use crate::{
|
|
assist_context::{AssistContext, Assists},
|
|
AssistId, AssistKind,
|
|
};
|
|
|
|
// Assist: add_turbo_fish
|
|
//
|
|
// Adds `::<_>` to a call of a generic method or function.
|
|
//
|
|
// ```
|
|
// fn make<T>() -> T { todo!() }
|
|
// fn main() {
|
|
// let x = make<|>();
|
|
// }
|
|
// ```
|
|
// ->
|
|
// ```
|
|
// fn make<T>() -> T { todo!() }
|
|
// fn main() {
|
|
// let x = make::<${0:_}>();
|
|
// }
|
|
// ```
|
|
pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
|
|
let ident = ctx.find_token_at_offset(SyntaxKind::IDENT).or_else(|| {
|
|
let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?;
|
|
if arg_list.args().count() > 0 {
|
|
return None;
|
|
}
|
|
mark::hit!(add_turbo_fish_after_call);
|
|
arg_list.l_paren_token()?.prev_token().filter(|it| it.kind() == SyntaxKind::IDENT)
|
|
})?;
|
|
let next_token = ident.next_token()?;
|
|
if next_token.kind() == T![::] {
|
|
mark::hit!(add_turbo_fish_one_fish_is_enough);
|
|
return None;
|
|
}
|
|
let name_ref = ast::NameRef::cast(ident.parent())?;
|
|
let def = match classify_name_ref(&ctx.sema, &name_ref)? {
|
|
NameRefClass::Definition(def) => def,
|
|
NameRefClass::ExternCrate(_) | NameRefClass::FieldShorthand { .. } => return None,
|
|
};
|
|
let fun = match def {
|
|
Definition::ModuleDef(hir::ModuleDef::Function(it)) => it,
|
|
_ => return None,
|
|
};
|
|
let generics = hir::GenericDef::Function(fun).params(ctx.sema.db);
|
|
if generics.is_empty() {
|
|
mark::hit!(add_turbo_fish_non_generic);
|
|
return None;
|
|
}
|
|
acc.add(
|
|
AssistId("add_turbo_fish", AssistKind::RefactorRewrite),
|
|
"Add `::<>`",
|
|
ident.text_range(),
|
|
|builder| match ctx.config.snippet_cap {
|
|
Some(cap) => builder.insert_snippet(cap, ident.text_range().end(), "::<${0:_}>"),
|
|
None => builder.insert(ident.text_range().end(), "::<_>"),
|
|
},
|
|
)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::tests::{check_assist, check_assist_not_applicable};
|
|
|
|
use super::*;
|
|
use test_utils::mark;
|
|
|
|
#[test]
|
|
fn add_turbo_fish_function() {
|
|
check_assist(
|
|
add_turbo_fish,
|
|
r#"
|
|
fn make<T>() -> T {}
|
|
fn main() {
|
|
make<|>();
|
|
}
|
|
"#,
|
|
r#"
|
|
fn make<T>() -> T {}
|
|
fn main() {
|
|
make::<${0:_}>();
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn add_turbo_fish_after_call() {
|
|
mark::check!(add_turbo_fish_after_call);
|
|
check_assist(
|
|
add_turbo_fish,
|
|
r#"
|
|
fn make<T>() -> T {}
|
|
fn main() {
|
|
make()<|>;
|
|
}
|
|
"#,
|
|
r#"
|
|
fn make<T>() -> T {}
|
|
fn main() {
|
|
make::<${0:_}>();
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn add_turbo_fish_method() {
|
|
check_assist(
|
|
add_turbo_fish,
|
|
r#"
|
|
struct S;
|
|
impl S {
|
|
fn make<T>(&self) -> T {}
|
|
}
|
|
fn main() {
|
|
S.make<|>();
|
|
}
|
|
"#,
|
|
r#"
|
|
struct S;
|
|
impl S {
|
|
fn make<T>(&self) -> T {}
|
|
}
|
|
fn main() {
|
|
S.make::<${0:_}>();
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn add_turbo_fish_one_fish_is_enough() {
|
|
mark::check!(add_turbo_fish_one_fish_is_enough);
|
|
check_assist_not_applicable(
|
|
add_turbo_fish,
|
|
r#"
|
|
fn make<T>() -> T {}
|
|
fn main() {
|
|
make<|>::<()>();
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn add_turbo_fish_non_generic() {
|
|
mark::check!(add_turbo_fish_non_generic);
|
|
check_assist_not_applicable(
|
|
add_turbo_fish,
|
|
r#"
|
|
fn make() -> () {}
|
|
fn main() {
|
|
make<|>();
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
}
|