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     CompletionItem, CompletionItemKind, Completions,
  18 };
  19
  20 pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
  21     if !ctx.config.enable_postfix_completions {
  22         return;
  23     }
  24
  25     let dot_receiver = match &ctx.dot_receiver {
  26         Some(it) => it,
  27         None => return,
  28     };
  29
  30     let receiver_text =
  31         get_receiver_text(dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
  32
  33     let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
  34         Some(it) => it,
  35         None => return,
  36     };
  37
  38     let ref_removed_ty =
  39         std::iter::successors(Some(receiver_ty.clone()), |ty| ty.remove_ref()).last().unwrap();
  40
  41     let cap = match ctx.config.snippet_cap {
  42         Some(it) => it,
  43         None => return,
  44     };
  45     let try_enum = TryEnum::from_ty(&ctx.sema, &ref_removed_ty);
  46     if let Some(try_enum) = &try_enum {
  47         match try_enum {
  48             TryEnum::Result => {
  49                 postfix_snippet(
  50                     ctx,
  51                     cap,
  52                     &dot_receiver,
  53                     "ifl",
  54                     "if let Ok {}",
  55                     &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
  56                 )
  57                 .add_to(acc);
  58
  59                 postfix_snippet(
  60                     ctx,
  61                     cap,
  62                     &dot_receiver,
  63                     "while",
  64                     "while let Ok {}",
  65                     &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
  66                 )
  67                 .add_to(acc);
  68             }
  69             TryEnum::Option => {
  70                 postfix_snippet(
  71                     ctx,
  72                     cap,
  73                     &dot_receiver,
  74                     "ifl",
  75                     "if let Some {}",
  76                     &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
  77                 )
  78                 .add_to(acc);
  79
  80                 postfix_snippet(
  81                     ctx,
  82                     cap,
  83                     &dot_receiver,
  84                     "while",
  85                     "while let Some {}",
  86                     &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
  87                 )
  88                 .add_to(acc);
  89             }
  90         }
  91     } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
  92         postfix_snippet(
  93             ctx,
  94             cap,
  95             &dot_receiver,
  96             "if",
  97             "if expr {}",
  98             &format!("if {} {{\n    $0\n}}", receiver_text),
  99         )
 100         .add_to(acc);
 101         postfix_snippet(
 102             ctx,
 103             cap,
 104             &dot_receiver,
 105             "while",
 106             "while expr {}",
 107             &format!("while {} {{\n    $0\n}}", receiver_text),
 108         )
 109         .add_to(acc);
 110         postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
 111             .add_to(acc);
 112     }
 113
 114     postfix_snippet(ctx, cap, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
 115         .add_to(acc);
 116     postfix_snippet(
 117         ctx,
 118         cap,
 119         &dot_receiver,
 120         "refm",
 121         "&mut expr",
 122         &format!("&mut {}", receiver_text),
 123     )
 124     .add_to(acc);
 125
 126     // The rest of the postfix completions create an expression that moves an argument,
 127     // so it's better to consider references now to avoid breaking the compilation
 128     let dot_receiver = include_references(dot_receiver);
 129     let receiver_text =
 130         get_receiver_text(&dot_receiver, ctx.dot_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     CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
 301         .detail(detail)
 302         .kind(CompletionItemKind::Snippet)
 303         .snippet_edit(cap, edit)
 304 }
 305
 306 #[cfg(test)]
 307 mod tests {
 308     use expect_test::{expect, Expect};
 309
 310     use crate::{
 311         test_utils::{check_edit, completion_list},
 312         CompletionKind,
 313     };
 314
 315     fn check(ra_fixture: &str, expect: Expect) {
 316         let actual = completion_list(ra_fixture, CompletionKind::Postfix);
 317         expect.assert_eq(&actual)
 318     }
 319
 320     #[test]
 321     fn postfix_completion_works_for_trivial_path_expression() {
 322         check(
 323             r#"
 324 fn main() {
 325     let bar = true;
 326     bar.$0
 327 }
 328 "#,
 329             expect![[r#"
 330                 sn if    if expr {}
 331                 sn while while expr {}
 332                 sn not   !expr
 333                 sn ref   &expr
 334                 sn refm  &mut expr
 335                 sn match match expr {}
 336                 sn box   Box::new(expr)
 337                 sn ok    Ok(expr)
 338                 sn err   Err(expr)
 339                 sn some  Some(expr)
 340                 sn dbg   dbg!(expr)
 341                 sn dbgr  dbg!(&expr)
 342                 sn call  function(expr)
 343                 sn let   let
 344                 sn letm  let mut
 345             "#]],
 346         );
 347     }
 348
 349     #[test]
 350     fn postfix_completion_works_for_function_calln() {
 351         check(
 352             r#"
 353 fn foo(elt: bool) -> bool {
 354     !elt
 355 }
 356
 357 fn main() {
 358     let bar = true;
 359     foo(bar.$0)
 360 }
 361 "#,
 362             expect![[r#"
 363                 sn if    if expr {}
 364                 sn while while expr {}
 365                 sn not   !expr
 366                 sn ref   &expr
 367                 sn refm  &mut expr
 368                 sn match match expr {}
 369                 sn box   Box::new(expr)
 370                 sn ok    Ok(expr)
 371                 sn err   Err(expr)
 372                 sn some  Some(expr)
 373                 sn dbg   dbg!(expr)
 374                 sn dbgr  dbg!(&expr)
 375                 sn call  function(expr)
 376             "#]],
 377         );
 378     }
 379
 380     #[test]
 381     fn postfix_type_filtering() {
 382         check(
 383             r#"
 384 fn main() {
 385     let bar: u8 = 12;
 386     bar.$0
 387 }
 388 "#,
 389             expect![[r#"
 390                 sn ref   &expr
 391                 sn refm  &mut expr
 392                 sn match match expr {}
 393                 sn box   Box::new(expr)
 394                 sn ok    Ok(expr)
 395                 sn err   Err(expr)
 396                 sn some  Some(expr)
 397                 sn dbg   dbg!(expr)
 398                 sn dbgr  dbg!(&expr)
 399                 sn call  function(expr)
 400                 sn let   let
 401                 sn letm  let mut
 402             "#]],
 403         )
 404     }
 405
 406     #[test]
 407     fn let_middle_block() {
 408         check(
 409             r#"
 410 fn main() {
 411     baz.l$0
 412     res
 413 }
 414 "#,
 415             expect![[r#"
 416                 sn if    if expr {}
 417                 sn while while expr {}
 418                 sn not   !expr
 419                 sn ref   &expr
 420                 sn refm  &mut expr
 421                 sn match match expr {}
 422                 sn box   Box::new(expr)
 423                 sn ok    Ok(expr)
 424                 sn err   Err(expr)
 425                 sn some  Some(expr)
 426                 sn dbg   dbg!(expr)
 427                 sn dbgr  dbg!(&expr)
 428                 sn call  function(expr)
 429                 sn let   let
 430                 sn letm  let mut
 431             "#]],
 432         );
 433     }
 434
 435     #[test]
 436     fn option_iflet() {
 437         check_edit(
 438             "ifl",
 439             r#"
 440 enum Option<T> { Some(T), None }
 441
 442 fn main() {
 443     let bar = Option::Some(true);
 444     bar.$0
 445 }
 446 "#,
 447             r#"
 448 enum Option<T> { Some(T), None }
 449
 450 fn main() {
 451     let bar = Option::Some(true);
 452     if let Some($1) = bar {
 453     $0
 454 }
 455 }
 456 "#,
 457         );
 458     }
 459
 460     #[test]
 461     fn result_match() {
 462         check_edit(
 463             "match",
 464             r#"
 465 enum Result<T, E> { Ok(T), Err(E) }
 466
 467 fn main() {
 468     let bar = Result::Ok(true);
 469     bar.$0
 470 }
 471 "#,
 472             r#"
 473 enum Result<T, E> { Ok(T), Err(E) }
 474
 475 fn main() {
 476     let bar = Result::Ok(true);
 477     match bar {
 478     Ok(${1:_}) => {$2},
 479     Err(${3:_}) => {$0},
 480 }
 481 }
 482 "#,
 483         );
 484     }
 485
 486     #[test]
 487     fn postfix_completion_works_for_ambiguous_float_literal() {
 488         check_edit("refm", r#"fn main() { 42.$0 }"#, r#"fn main() { &mut 42 }"#)
 489     }
 490
 491     #[test]
 492     fn works_in_simple_macro() {
 493         check_edit(
 494             "dbg",
 495             r#"
 496 macro_rules! m { ($e:expr) => { $e } }
 497 fn main() {
 498     let bar: u8 = 12;
 499     m!(bar.d$0)
 500 }
 501 "#,
 502             r#"
 503 macro_rules! m { ($e:expr) => { $e } }
 504 fn main() {
 505     let bar: u8 = 12;
 506     m!(dbg!(bar))
 507 }
 508 "#,
 509         );
 510     }
 511
 512     #[test]
 513     fn postfix_completion_for_references() {
 514         check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
 515         check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
 516         check_edit(
 517             "ifl",
 518             r#"
 519 enum Option<T> { Some(T), None }
 520
 521 fn main() {
 522     let bar = &Option::Some(true);
 523     bar.$0
 524 }
 525 "#,
 526             r#"
 527 enum Option<T> { Some(T), None }
 528
 529 fn main() {
 530     let bar = &Option::Some(true);
 531     if let Some($1) = bar {
 532     $0
 533 }
 534 }
 535 "#,
 536         )
 537     }
 538
 539     #[test]
 540     fn postfix_completion_for_format_like_strings() {
 541         check_edit(
 542             "format",
 543             r#"fn main() { "{some_var:?}".$0 }"#,
 544             r#"fn main() { format!("{:?}", some_var) }"#,
 545         );
 546         check_edit(
 547             "panic",
 548             r#"fn main() { "Panic with {a}".$0 }"#,
 549             r#"fn main() { panic!("Panic with {}", a) }"#,
 550         );
 551         check_edit(
 552             "println",
 553             r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".$0 }"#,
 554             r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
 555         );
 556         check_edit(
 557             "loge",
 558             r#"fn main() { "{2+2}".$0 }"#,
 559             r#"fn main() { log::error!("{}", 2+2) }"#,
 560         );
 561         check_edit(
 562             "logt",
 563             r#"fn main() { "{2+2}".$0 }"#,
 564             r#"fn main() { log::trace!("{}", 2+2) }"#,
 565         );
 566         check_edit(
 567             "logd",
 568             r#"fn main() { "{2+2}".$0 }"#,
 569             r#"fn main() { log::debug!("{}", 2+2) }"#,
 570         );
 571         check_edit("logi", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::info!("{}", 2+2) }"#);
 572         check_edit("logw", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::warn!("{}", 2+2) }"#);
 573         check_edit(
 574             "loge",
 575             r#"fn main() { "{2+2}".$0 }"#,
 576             r#"fn main() { log::error!("{}", 2+2) }"#,
 577         );
 578     }
 579 }