crates/ide_completion/src/completions/postfix.rs

   1 //! Postfix completions, like `Ok(10).ifl$0` => `if let Ok() = Ok(10) { $0 }`.
   2
   3 mod format_like;
   4
   5 use hir::Documentation;
   6 use ide_db::{
   7     helpers::{insert_use::ImportScope, FamousDefs, SnippetCap},
   8     ty_filter::TryEnum,
   9 };
  10 use syntax::{
  11     ast::{self, AstNode, AstToken},
  12     SyntaxKind::{EXPR_STMT, STMT_LIST},
  13     TextRange, TextSize,
  14 };
  15 use text_edit::TextEdit;
  16
  17 use crate::{
  18     completions::postfix::format_like::add_format_like_completions, context::CompletionContext,
  19     item::Builder, patterns::ImmediateLocation, CompletionItem, CompletionItemKind,
  20     CompletionRelevance, Completions, SnippetScope,
  21 };
  22
  23 pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
  24     if !ctx.config.enable_postfix_completions {
  25         return;
  26     }
  27
  28     let (dot_receiver, receiver_is_ambiguous_float_literal) = match &ctx.completion_location {
  29         Some(ImmediateLocation::MethodCall { receiver: Some(it), .. }) => (it, false),
  30         Some(ImmediateLocation::FieldAccess {
  31             receiver: Some(it),
  32             receiver_is_ambiguous_float_literal,
  33         }) => (it, *receiver_is_ambiguous_float_literal),
  34         _ => return,
  35     };
  36
  37     let receiver_text = get_receiver_text(dot_receiver, receiver_is_ambiguous_float_literal);
  38
  39     let receiver_ty = match ctx.sema.type_of_expr(dot_receiver) {
  40         Some(it) => it.original,
  41         None => return,
  42     };
  43
  44     // Suggest .await syntax for types that implement Future trait
  45     if receiver_ty.impls_future(ctx.db) {
  46         let mut item =
  47             CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), "await");
  48         item.detail("expr.await");
  49         item.add_to(acc);
  50     }
  51
  52     let cap = match ctx.config.snippet_cap {
  53         Some(it) => it,
  54         None => return,
  55     };
  56
  57     let postfix_snippet = match build_postfix_snippet_builder(ctx, cap, &dot_receiver) {
  58         Some(it) => it,
  59         None => return,
  60     };
  61
  62     if !ctx.config.snippets.is_empty() {
  63         add_custom_postfix_completions(acc, ctx, &postfix_snippet, &receiver_text);
  64     }
  65
  66     let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty.strip_references());
  67     if let Some(try_enum) = &try_enum {
  68         match try_enum {
  69             TryEnum::Result => {
  70                 postfix_snippet(
  71                     "ifl",
  72                     "if let Ok {}",
  73                     &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
  74                 )
  75                 .add_to(acc);
  76
  77                 postfix_snippet(
  78                     "while",
  79                     "while let Ok {}",
  80                     &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
  81                 )
  82                 .add_to(acc);
  83             }
  84             TryEnum::Option => {
  85                 postfix_snippet(
  86                     "ifl",
  87                     "if let Some {}",
  88                     &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
  89                 )
  90                 .add_to(acc);
  91
  92                 postfix_snippet(
  93                     "while",
  94                     "while let Some {}",
  95                     &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
  96                 )
  97                 .add_to(acc);
  98             }
  99         }
 100     } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
 101         postfix_snippet("if", "if expr {}", &format!("if {} {{\n    $0\n}}", receiver_text))
 102             .add_to(acc);
 103         postfix_snippet(
 104             "while",
 105             "while expr {}",
 106             &format!("while {} {{\n    $0\n}}", receiver_text),
 107         )
 108         .add_to(acc);
 109         postfix_snippet("not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
 110     } else if let Some(trait_) = FamousDefs(&ctx.sema, ctx.krate).core_iter_IntoIterator() {
 111         if receiver_ty.impls_trait(ctx.db, trait_, &[]) {
 112             postfix_snippet(
 113                 "for",
 114                 "for ele in expr {}",
 115                 &format!("for ele in {} {{\n    $0\n}}", receiver_text),
 116             )
 117             .add_to(acc);
 118         }
 119     }
 120
 121     postfix_snippet("ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
 122     postfix_snippet("refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
 123
 124     // The rest of the postfix completions create an expression that moves an argument,
 125     // so it's better to consider references now to avoid breaking the compilation
 126     let dot_receiver = include_references(dot_receiver);
 127     let receiver_text = get_receiver_text(&dot_receiver, receiver_is_ambiguous_float_literal);
 128     let postfix_snippet = match build_postfix_snippet_builder(ctx, cap, &dot_receiver) {
 129         Some(it) => it,
 130         None => return,
 131     };
 132
 133     match try_enum {
 134         Some(try_enum) => match try_enum {
 135             TryEnum::Result => {
 136                 postfix_snippet(
 137                     "match",
 138                     "match expr {}",
 139                     &format!("match {} {{\n    Ok(${{1:_}}) => {{$2}},\n    Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
 140                 )
 141                 .add_to(acc);
 142             }
 143             TryEnum::Option => {
 144                 postfix_snippet(
 145                     "match",
 146                     "match expr {}",
 147                     &format!(
 148                         "match {} {{\n    Some(${{1:_}}) => {{$2}},\n    None => {{$0}},\n}}",
 149                         receiver_text
 150                     ),
 151                 )
 152                 .add_to(acc);
 153             }
 154         },
 155         None => {
 156             postfix_snippet(
 157                 "match",
 158                 "match expr {}",
 159                 &format!("match {} {{\n    ${{1:_}} => {{$0}},\n}}", receiver_text),
 160             )
 161             .add_to(acc);
 162         }
 163     }
 164
 165     postfix_snippet("box", "Box::new(expr)", &format!("Box::new({})", receiver_text)).add_to(acc);
 166     postfix_snippet("dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
 167     postfix_snippet("dbgr", "dbg!(&expr)", &format!("dbg!(&{})", receiver_text)).add_to(acc);
 168     postfix_snippet("call", "function(expr)", &format!("${{1}}({})", receiver_text)).add_to(acc);
 169
 170     if let Some(parent) = dot_receiver.syntax().parent().and_then(|p| p.parent()) {
 171         if matches!(parent.kind(), STMT_LIST | EXPR_STMT) {
 172             postfix_snippet("let", "let", &format!("let $0 = {};", receiver_text)).add_to(acc);
 173             postfix_snippet("letm", "let mut", &format!("let mut $0 = {};", receiver_text))
 174                 .add_to(acc);
 175         }
 176     }
 177
 178     if let ast::Expr::Literal(literal) = dot_receiver.clone() {
 179         if let Some(literal_text) = ast::String::cast(literal.token()) {
 180             add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
 181         }
 182     }
 183 }
 184
 185 fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
 186     if receiver_is_ambiguous_float_literal {
 187         let text = receiver.syntax().text();
 188         let without_dot = ..text.len() - TextSize::of('.');
 189         text.slice(without_dot).to_string()
 190     } else {
 191         receiver.to_string()
 192     }
 193 }
 194
 195 fn include_references(initial_element: &ast::Expr) -> ast::Expr {
 196     let mut resulting_element = initial_element.clone();
 197     while let Some(parent_ref_element) =
 198         resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
 199     {
 200         resulting_element = ast::Expr::from(parent_ref_element);
 201     }
 202     resulting_element
 203 }
 204
 205 fn build_postfix_snippet_builder<'ctx>(
 206     ctx: &'ctx CompletionContext,
 207     cap: SnippetCap,
 208     receiver: &'ctx ast::Expr,
 209 ) -> Option<impl Fn(&str, &str, &str) -> Builder + 'ctx> {
 210     let receiver_syntax = receiver.syntax();
 211     let receiver_range = ctx.sema.original_range_opt(receiver_syntax)?.range;
 212     let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
 213
 214     // Wrapping impl Fn in an option ruins lifetime inference for the parameters in a way that
 215     // can't be annotated for the closure, hence fix it by constructing it without the Option first
 216     fn build<'ctx>(
 217         ctx: &'ctx CompletionContext,
 218         cap: SnippetCap,
 219         delete_range: TextRange,
 220     ) -> impl Fn(&str, &str, &str) -> Builder + 'ctx {
 221         move |label, detail, snippet| {
 222             let edit = TextEdit::replace(delete_range, snippet.to_string());
 223             let mut item =
 224                 CompletionItem::new(CompletionItemKind::Snippet, ctx.source_range(), label);
 225             item.detail(detail).snippet_edit(cap, edit);
 226             if ctx.original_token.text() == label {
 227                 let relevance =
 228                     CompletionRelevance { exact_postfix_snippet_match: true, ..Default::default() };
 229                 item.set_relevance(relevance);
 230             }
 231
 232             item
 233         }
 234     }
 235     Some(build(ctx, cap, delete_range))
 236 }
 237
 238 fn add_custom_postfix_completions(
 239     acc: &mut Completions,
 240     ctx: &CompletionContext,
 241     postfix_snippet: impl Fn(&str, &str, &str) -> Builder,
 242     receiver_text: &str,
 243 ) -> Option<()> {
 244     let import_scope = ImportScope::find_insert_use_container(&ctx.token.parent()?, &ctx.sema)?;
 245     ctx.config.postfix_snippets().filter(|(_, snip)| snip.scope == SnippetScope::Expr).for_each(
 246         |(trigger, snippet)| {
 247             let imports = match snippet.imports(ctx, &import_scope) {
 248                 Some(imports) => imports,
 249                 None => return,
 250             };
 251             let body = snippet.postfix_snippet(&receiver_text);
 252             let mut builder =
 253                 postfix_snippet(trigger, snippet.description.as_deref().unwrap_or_default(), &body);
 254             builder.documentation(Documentation::new(format!("```rust\n{}\n```", body)));
 255             for import in imports.into_iter() {
 256                 builder.add_import(import);
 257             }
 258             builder.add_to(acc);
 259         },
 260     );
 261     None
 262 }
 263
 264 #[cfg(test)]
 265 mod tests {
 266     use expect_test::{expect, Expect};
 267
 268     use crate::{
 269         tests::{check_edit, check_edit_with_config, completion_list, TEST_CONFIG},
 270         CompletionConfig, Snippet,
 271     };
 272
 273     fn check(ra_fixture: &str, expect: Expect) {
 274         let actual = completion_list(ra_fixture);
 275         expect.assert_eq(&actual)
 276     }
 277
 278     #[test]
 279     fn postfix_completion_works_for_trivial_path_expression() {
 280         check(
 281             r#"
 282 fn main() {
 283     let bar = true;
 284     bar.$0
 285 }
 286 "#,
 287             expect![[r#"
 288                 sn if    if expr {}
 289                 sn while while expr {}
 290                 sn not   !expr
 291                 sn ref   &expr
 292                 sn refm  &mut expr
 293                 sn match match expr {}
 294                 sn box   Box::new(expr)
 295                 sn ok    Ok(expr)
 296                 sn err   Err(expr)
 297                 sn some  Some(expr)
 298                 sn dbg   dbg!(expr)
 299                 sn dbgr  dbg!(&expr)
 300                 sn call  function(expr)
 301                 sn let   let
 302                 sn letm  let mut
 303             "#]],
 304         );
 305     }
 306
 307     #[test]
 308     fn postfix_completion_works_for_function_calln() {
 309         check(
 310             r#"
 311 fn foo(elt: bool) -> bool {
 312     !elt
 313 }
 314
 315 fn main() {
 316     let bar = true;
 317     foo(bar.$0)
 318 }
 319 "#,
 320             expect![[r#"
 321                 sn if    if expr {}
 322                 sn while while expr {}
 323                 sn not   !expr
 324                 sn ref   &expr
 325                 sn refm  &mut expr
 326                 sn match match expr {}
 327                 sn box   Box::new(expr)
 328                 sn ok    Ok(expr)
 329                 sn err   Err(expr)
 330                 sn some  Some(expr)
 331                 sn dbg   dbg!(expr)
 332                 sn dbgr  dbg!(&expr)
 333                 sn call  function(expr)
 334             "#]],
 335         );
 336     }
 337
 338     #[test]
 339     fn postfix_type_filtering() {
 340         check(
 341             r#"
 342 fn main() {
 343     let bar: u8 = 12;
 344     bar.$0
 345 }
 346 "#,
 347             expect![[r#"
 348                 sn ref   &expr
 349                 sn refm  &mut expr
 350                 sn match match expr {}
 351                 sn box   Box::new(expr)
 352                 sn ok    Ok(expr)
 353                 sn err   Err(expr)
 354                 sn some  Some(expr)
 355                 sn dbg   dbg!(expr)
 356                 sn dbgr  dbg!(&expr)
 357                 sn call  function(expr)
 358                 sn let   let
 359                 sn letm  let mut
 360             "#]],
 361         )
 362     }
 363
 364     #[test]
 365     fn let_middle_block() {
 366         check(
 367             r#"
 368 fn main() {
 369     baz.l$0
 370     res
 371 }
 372 "#,
 373             expect![[r#"
 374                 sn if    if expr {}
 375                 sn while while expr {}
 376                 sn not   !expr
 377                 sn ref   &expr
 378                 sn refm  &mut expr
 379                 sn match match expr {}
 380                 sn box   Box::new(expr)
 381                 sn ok    Ok(expr)
 382                 sn err   Err(expr)
 383                 sn some  Some(expr)
 384                 sn dbg   dbg!(expr)
 385                 sn dbgr  dbg!(&expr)
 386                 sn call  function(expr)
 387                 sn let   let
 388                 sn letm  let mut
 389             "#]],
 390         );
 391     }
 392
 393     #[test]
 394     fn option_iflet() {
 395         check_edit(
 396             "ifl",
 397             r#"
 398 //- minicore: option
 399 fn main() {
 400     let bar = Some(true);
 401     bar.$0
 402 }
 403 "#,
 404             r#"
 405 fn main() {
 406     let bar = Some(true);
 407     if let Some($1) = bar {
 408     $0
 409 }
 410 }
 411 "#,
 412         );
 413     }
 414
 415     #[test]
 416     fn result_match() {
 417         check_edit(
 418             "match",
 419             r#"
 420 //- minicore: result
 421 fn main() {
 422     let bar = Ok(true);
 423     bar.$0
 424 }
 425 "#,
 426             r#"
 427 fn main() {
 428     let bar = Ok(true);
 429     match bar {
 430     Ok(${1:_}) => {$2},
 431     Err(${3:_}) => {$0},
 432 }
 433 }
 434 "#,
 435         );
 436     }
 437
 438     #[test]
 439     fn postfix_completion_works_for_ambiguous_float_literal() {
 440         check_edit("refm", r#"fn main() { 42.$0 }"#, r#"fn main() { &mut 42 }"#)
 441     }
 442
 443     #[test]
 444     fn works_in_simple_macro() {
 445         check_edit(
 446             "dbg",
 447             r#"
 448 macro_rules! m { ($e:expr) => { $e } }
 449 fn main() {
 450     let bar: u8 = 12;
 451     m!(bar.d$0)
 452 }
 453 "#,
 454             r#"
 455 macro_rules! m { ($e:expr) => { $e } }
 456 fn main() {
 457     let bar: u8 = 12;
 458     m!(dbg!(bar))
 459 }
 460 "#,
 461         );
 462     }
 463
 464     #[test]
 465     fn postfix_completion_for_references() {
 466         check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
 467         check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
 468         check_edit(
 469             "ifl",
 470             r#"
 471 //- minicore: option
 472 fn main() {
 473     let bar = &Some(true);
 474     bar.$0
 475 }
 476 "#,
 477             r#"
 478 fn main() {
 479     let bar = &Some(true);
 480     if let Some($1) = bar {
 481     $0
 482 }
 483 }
 484 "#,
 485         )
 486     }
 487
 488     #[test]
 489     fn custom_postfix_completion() {
 490         check_edit_with_config(
 491             CompletionConfig {
 492                 snippets: vec![Snippet::new(
 493                     &[],
 494                     &["break".into()],
 495                     &["ControlFlow::Break(${receiver})".into()],
 496                     "",
 497                     &["core::ops::ControlFlow".into()],
 498                     crate::SnippetScope::Expr,
 499                 )
 500                 .unwrap()],
 501                 ..TEST_CONFIG
 502             },
 503             "break",
 504             r#"
 505 //- minicore: try
 506 fn main() { 42.$0 }
 507 "#,
 508             r#"
 509 use core::ops::ControlFlow;
 510
 511 fn main() { ControlFlow::Break(42) }
 512 "#,
 513         );
 514     }
 515
 516     #[test]
 517     fn postfix_completion_for_format_like_strings() {
 518         check_edit(
 519             "format",
 520             r#"fn main() { "{some_var:?}".$0 }"#,
 521             r#"fn main() { format!("{:?}", some_var) }"#,
 522         );
 523         check_edit(
 524             "panic",
 525             r#"fn main() { "Panic with {a}".$0 }"#,
 526             r#"fn main() { panic!("Panic with {}", a) }"#,
 527         );
 528         check_edit(
 529             "println",
 530             r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".$0 }"#,
 531             r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
 532         );
 533         check_edit(
 534             "loge",
 535             r#"fn main() { "{2+2}".$0 }"#,
 536             r#"fn main() { log::error!("{}", 2+2) }"#,
 537         );
 538         check_edit(
 539             "logt",
 540             r#"fn main() { "{2+2}".$0 }"#,
 541             r#"fn main() { log::trace!("{}", 2+2) }"#,
 542         );
 543         check_edit(
 544             "logd",
 545             r#"fn main() { "{2+2}".$0 }"#,
 546             r#"fn main() { log::debug!("{}", 2+2) }"#,
 547         );
 548         check_edit("logi", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::info!("{}", 2+2) }"#);
 549         check_edit("logw", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::warn!("{}", 2+2) }"#);
 550         check_edit(
 551             "loge",
 552             r#"fn main() { "{2+2}".$0 }"#,
 553             r#"fn main() { log::error!("{}", 2+2) }"#,
 554         );
 555     }
 556 }