crates/ide_assists/src/handlers/add_turbo_fish.rs

   1 use ide_db::defs::{Definition, NameRefClass};
   2 use syntax::{ast, AstNode, SyntaxKind, T};
   3
   4 use crate::{
   5     assist_context::{AssistContext, Assists},
   6     AssistId, AssistKind,
   7 };
   8
   9 // Assist: add_turbo_fish
  10 //
  11 // Adds `::<_>` to a call of a generic method or function.
  12 //
  13 // ```
  14 // fn make<T>() -> T { todo!() }
  15 // fn main() {
  16 //     let x = make$0();
  17 // }
  18 // ```
  19 // ->
  20 // ```
  21 // fn make<T>() -> T { todo!() }
  22 // fn main() {
  23 //     let x = make::<${0:_}>();
  24 // }
  25 // ```
  26 pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
  27     let ident = ctx.find_token_syntax_at_offset(SyntaxKind::IDENT).or_else(|| {
  28         let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?;
  29         if arg_list.args().next().is_some() {
  30             return None;
  31         }
  32         cov_mark::hit!(add_turbo_fish_after_call);
  33         cov_mark::hit!(add_type_ascription_after_call);
  34         arg_list.l_paren_token()?.prev_token().filter(|it| it.kind() == SyntaxKind::IDENT)
  35     })?;
  36     let next_token = ident.next_token()?;
  37     if next_token.kind() == T![::] {
  38         cov_mark::hit!(add_turbo_fish_one_fish_is_enough);
  39         return None;
  40     }
  41     let name_ref = ast::NameRef::cast(ident.parent()?)?;
  42     let def = match NameRefClass::classify(&ctx.sema, &name_ref)? {
  43         NameRefClass::Definition(def) => def,
  44         NameRefClass::FieldShorthand { .. } => return None,
  45     };
  46     let fun = match def {
  47         Definition::Function(it) => it,
  48         _ => return None,
  49     };
  50     let generics = hir::GenericDef::Function(fun).params(ctx.sema.db);
  51     if generics.is_empty() {
  52         cov_mark::hit!(add_turbo_fish_non_generic);
  53         return None;
  54     }
  55
  56     if let Some(let_stmt) = ctx.find_node_at_offset::<ast::LetStmt>() {
  57         if let_stmt.colon_token().is_none() {
  58             let type_pos = let_stmt.pat()?.syntax().last_token()?.text_range().end();
  59             let semi_pos = let_stmt.syntax().last_token()?.text_range().end();
  60
  61             acc.add(
  62                 AssistId("add_type_ascription", AssistKind::RefactorRewrite),
  63                 "Add `: _` before assignment operator",
  64                 ident.text_range(),
  65                 |builder| {
  66                     if let_stmt.semicolon_token().is_none() {
  67                         builder.insert(semi_pos, ";");
  68                     }
  69                     match ctx.config.snippet_cap {
  70                         Some(cap) => builder.insert_snippet(cap, type_pos, ": ${0:_}"),
  71                         None => builder.insert(type_pos, ": _"),
  72                     }
  73                 },
  74             )?
  75         } else {
  76             cov_mark::hit!(add_type_ascription_already_typed);
  77         }
  78     }
  79
  80     let number_of_arguments = generics.len();
  81     let fish_head = std::iter::repeat("_").take(number_of_arguments).collect::<Vec<_>>().join(",");
  82
  83     acc.add(
  84         AssistId("add_turbo_fish", AssistKind::RefactorRewrite),
  85         "Add `::<>`",
  86         ident.text_range(),
  87         |builder| match ctx.config.snippet_cap {
  88             Some(cap) => {
  89                 let snip = format!("::<${{0:{}}}>", fish_head);
  90                 builder.insert_snippet(cap, ident.text_range().end(), snip)
  91             }
  92             None => {
  93                 let snip = format!("::<{}>", fish_head);
  94                 builder.insert(ident.text_range().end(), snip);
  95             }
  96         },
  97     )
  98 }
  99
 100 #[cfg(test)]
 101 mod tests {
 102     use crate::tests::{check_assist, check_assist_by_label, check_assist_not_applicable};
 103
 104     use super::*;
 105
 106     #[test]
 107     fn add_turbo_fish_function() {
 108         check_assist(
 109             add_turbo_fish,
 110             r#"
 111 fn make<T>() -> T {}
 112 fn main() {
 113     make$0();
 114 }
 115 "#,
 116             r#"
 117 fn make<T>() -> T {}
 118 fn main() {
 119     make::<${0:_}>();
 120 }
 121 "#,
 122         );
 123     }
 124
 125     #[test]
 126     fn add_turbo_fish_function_multiple_generic_types() {
 127         check_assist(
 128             add_turbo_fish,
 129             r#"
 130 fn make<T, A>() -> T {}
 131 fn main() {
 132     make$0();
 133 }
 134 "#,
 135             r#"
 136 fn make<T, A>() -> T {}
 137 fn main() {
 138     make::<${0:_,_}>();
 139 }
 140 "#,
 141         );
 142     }
 143
 144     #[test]
 145     fn add_turbo_fish_function_many_generic_types() {
 146         check_assist(
 147             add_turbo_fish,
 148             r#"
 149 fn make<T, A, B, C, D, E, F>() -> T {}
 150 fn main() {
 151     make$0();
 152 }
 153 "#,
 154             r#"
 155 fn make<T, A, B, C, D, E, F>() -> T {}
 156 fn main() {
 157     make::<${0:_,_,_,_,_,_,_}>();
 158 }
 159 "#,
 160         );
 161     }
 162
 163     #[test]
 164     fn add_turbo_fish_after_call() {
 165         cov_mark::check!(add_turbo_fish_after_call);
 166         check_assist(
 167             add_turbo_fish,
 168             r#"
 169 fn make<T>() -> T {}
 170 fn main() {
 171     make()$0;
 172 }
 173 "#,
 174             r#"
 175 fn make<T>() -> T {}
 176 fn main() {
 177     make::<${0:_}>();
 178 }
 179 "#,
 180         );
 181     }
 182
 183     #[test]
 184     fn add_turbo_fish_method() {
 185         check_assist(
 186             add_turbo_fish,
 187             r#"
 188 struct S;
 189 impl S {
 190     fn make<T>(&self) -> T {}
 191 }
 192 fn main() {
 193     S.make$0();
 194 }
 195 "#,
 196             r#"
 197 struct S;
 198 impl S {
 199     fn make<T>(&self) -> T {}
 200 }
 201 fn main() {
 202     S.make::<${0:_}>();
 203 }
 204 "#,
 205         );
 206     }
 207
 208     #[test]
 209     fn add_turbo_fish_one_fish_is_enough() {
 210         cov_mark::check!(add_turbo_fish_one_fish_is_enough);
 211         check_assist_not_applicable(
 212             add_turbo_fish,
 213             r#"
 214 fn make<T>() -> T {}
 215 fn main() {
 216     make$0::<()>();
 217 }
 218 "#,
 219         );
 220     }
 221
 222     #[test]
 223     fn add_turbo_fish_non_generic() {
 224         cov_mark::check!(add_turbo_fish_non_generic);
 225         check_assist_not_applicable(
 226             add_turbo_fish,
 227             r#"
 228 fn make() -> () {}
 229 fn main() {
 230     make$0();
 231 }
 232 "#,
 233         );
 234     }
 235
 236     #[test]
 237     fn add_type_ascription_function() {
 238         check_assist_by_label(
 239             add_turbo_fish,
 240             r#"
 241 fn make<T>() -> T {}
 242 fn main() {
 243     let x = make$0();
 244 }
 245 "#,
 246             r#"
 247 fn make<T>() -> T {}
 248 fn main() {
 249     let x: ${0:_} = make();
 250 }
 251 "#,
 252             "Add `: _` before assignment operator",
 253         );
 254     }
 255
 256     #[test]
 257     fn add_type_ascription_after_call() {
 258         cov_mark::check!(add_type_ascription_after_call);
 259         check_assist_by_label(
 260             add_turbo_fish,
 261             r#"
 262 fn make<T>() -> T {}
 263 fn main() {
 264     let x = make()$0;
 265 }
 266 "#,
 267             r#"
 268 fn make<T>() -> T {}
 269 fn main() {
 270     let x: ${0:_} = make();
 271 }
 272 "#,
 273             "Add `: _` before assignment operator",
 274         );
 275     }
 276
 277     #[test]
 278     fn add_type_ascription_method() {
 279         check_assist_by_label(
 280             add_turbo_fish,
 281             r#"
 282 struct S;
 283 impl S {
 284     fn make<T>(&self) -> T {}
 285 }
 286 fn main() {
 287     let x = S.make$0();
 288 }
 289 "#,
 290             r#"
 291 struct S;
 292 impl S {
 293     fn make<T>(&self) -> T {}
 294 }
 295 fn main() {
 296     let x: ${0:_} = S.make();
 297 }
 298 "#,
 299             "Add `: _` before assignment operator",
 300         );
 301     }
 302
 303     #[test]
 304     fn add_type_ascription_already_typed() {
 305         cov_mark::check!(add_type_ascription_already_typed);
 306         check_assist(
 307             add_turbo_fish,
 308             r#"
 309 fn make<T>() -> T {}
 310 fn main() {
 311     let x: () = make$0();
 312 }
 313 "#,
 314             r#"
 315 fn make<T>() -> T {}
 316 fn main() {
 317     let x: () = make::<${0:_}>();
 318 }
 319 "#,
 320         );
 321     }
 322
 323     #[test]
 324     fn add_type_ascription_append_semicolon() {
 325         check_assist_by_label(
 326             add_turbo_fish,
 327             r#"
 328 fn make<T>() -> T {}
 329 fn main() {
 330     let x = make$0()
 331 }
 332 "#,
 333             r#"
 334 fn make<T>() -> T {}
 335 fn main() {
 336     let x: ${0:_} = make();
 337 }
 338 "#,
 339             "Add `: _` before assignment operator",
 340         );
 341     }
 342 }