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