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