1 use ide_db::defs::{Definition, NameRefClass};
2 use itertools::Itertools;
3 use syntax::{ast, AstNode, SyntaxKind, T};
6 assist_context::{AssistContext, Assists},
10 // Assist: add_turbo_fish
12 // Adds `::<_>` to a call of a generic method or function.
15 // fn make<T>() -> T { todo!() }
22 // fn make<T>() -> T { todo!() }
24 // let x = make::<${0:_}>();
27 pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
28 let ident = ctx.find_token_syntax_at_offset(SyntaxKind::IDENT).or_else(|| {
29 let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?;
30 if arg_list.args().next().is_some() {
33 cov_mark::hit!(add_turbo_fish_after_call);
34 cov_mark::hit!(add_type_ascription_after_call);
35 arg_list.l_paren_token()?.prev_token().filter(|it| it.kind() == SyntaxKind::IDENT)
37 let next_token = ident.next_token()?;
38 if next_token.kind() == T![::] {
39 cov_mark::hit!(add_turbo_fish_one_fish_is_enough);
42 let name_ref = ast::NameRef::cast(ident.parent()?)?;
43 let def = match NameRefClass::classify(&ctx.sema, &name_ref)? {
44 NameRefClass::Definition(def) => def,
45 NameRefClass::FieldShorthand { .. } => return None,
48 Definition::Function(it) => it,
51 let generics = hir::GenericDef::Function(fun).params(ctx.sema.db);
52 if generics.is_empty() {
53 cov_mark::hit!(add_turbo_fish_non_generic);
57 if let Some(let_stmt) = ctx.find_node_at_offset::<ast::LetStmt>() {
58 if let_stmt.colon_token().is_none() {
59 let type_pos = let_stmt.pat()?.syntax().last_token()?.text_range().end();
60 let semi_pos = let_stmt.syntax().last_token()?.text_range().end();
63 AssistId("add_type_ascription", AssistKind::RefactorRewrite),
64 "Add `: _` before assignment operator",
67 if let_stmt.semicolon_token().is_none() {
68 builder.insert(semi_pos, ";");
70 match ctx.config.snippet_cap {
71 Some(cap) => builder.insert_snippet(cap, type_pos, ": ${0:_}"),
72 None => builder.insert(type_pos, ": _"),
77 cov_mark::hit!(add_type_ascription_already_typed);
81 let number_of_arguments = generics
84 matches!(param, hir::GenericParam::TypeParam(_) | hir::GenericParam::ConstParam(_))
89 AssistId("add_turbo_fish", AssistKind::RefactorRewrite),
93 builder.trigger_signature_help();
94 match ctx.config.snippet_cap {
96 let snip = format!("::<{}>", get_snippet_fish_head(number_of_arguments));
97 builder.insert_snippet(cap, ident.text_range().end(), snip)
100 let fish_head = std::iter::repeat("_").take(number_of_arguments).format(", ");
101 let snip = format!("::<{}>", fish_head);
102 builder.insert(ident.text_range().end(), snip);
109 /// This will create a snippet string with tabstops marked
110 fn get_snippet_fish_head(number_of_arguments: usize) -> String {
111 let mut fish_head = (1..number_of_arguments)
112 .format_with("", |i, f| f(&format_args!("${{{}:_}}, ", i)))
115 // tabstop 0 is a special case and always the last one
116 fish_head.push_str("${0:_}");
122 use crate::tests::{check_assist, check_assist_by_label, check_assist_not_applicable};
127 fn add_turbo_fish_function() {
146 fn add_turbo_fish_function_multiple_generic_types() {
150 fn make<T, A>() -> T {}
156 fn make<T, A>() -> T {}
158 make::<${1:_}, ${0:_}>();
165 fn add_turbo_fish_function_many_generic_types() {
169 fn make<T, A, B, C, D, E, F>() -> T {}
175 fn make<T, A, B, C, D, E, F>() -> T {}
177 make::<${1:_}, ${2:_}, ${3:_}, ${4:_}, ${5:_}, ${6:_}, ${0:_}>();
184 fn add_turbo_fish_after_call() {
185 cov_mark::check!(add_turbo_fish_after_call);
204 fn add_turbo_fish_method() {
210 fn make<T>(&self) -> T {}
219 fn make<T>(&self) -> T {}
229 fn add_turbo_fish_one_fish_is_enough() {
230 cov_mark::check!(add_turbo_fish_one_fish_is_enough);
231 check_assist_not_applicable(
243 fn add_turbo_fish_non_generic() {
244 cov_mark::check!(add_turbo_fish_non_generic);
245 check_assist_not_applicable(
257 fn add_type_ascription_function() {
258 check_assist_by_label(
269 let x: ${0:_} = make();
272 "Add `: _` before assignment operator",
277 fn add_type_ascription_after_call() {
278 cov_mark::check!(add_type_ascription_after_call);
279 check_assist_by_label(
290 let x: ${0:_} = make();
293 "Add `: _` before assignment operator",
298 fn add_type_ascription_method() {
299 check_assist_by_label(
304 fn make<T>(&self) -> T {}
313 fn make<T>(&self) -> T {}
316 let x: ${0:_} = S.make();
319 "Add `: _` before assignment operator",
324 fn add_type_ascription_already_typed() {
325 cov_mark::check!(add_type_ascription_already_typed);
331 let x: () = make$0();
337 let x: () = make::<${0:_}>();
344 fn add_type_ascription_append_semicolon() {
345 check_assist_by_label(
356 let x: ${0:_} = make();
359 "Add `: _` before assignment operator",
364 fn add_turbo_fish_function_lifetime_parameter() {
368 fn make<'a, T, A>(t: T, a: A) {}
374 fn make<'a, T, A>(t: T, a: A) {}
376 make::<${1:_}, ${0:_}>(5, 2);
383 fn add_turbo_fish_function_const_parameter() {
387 fn make<T, const N: usize>(t: T) {}
393 fn make<T, const N: usize>(t: T) {}
395 make::<${1:_}, ${0:_}>(3);