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         .clone()
 305 }
 306
 307 #[cfg(test)]
 308 mod tests {
 309     use expect_test::{expect, Expect};
 310
 311     use crate::{
 312         test_utils::{check_edit, completion_list},
 313         CompletionKind,
 314     };
 315
 316     fn check(ra_fixture: &str, expect: Expect) {
 317         let actual = completion_list(ra_fixture, CompletionKind::Postfix);
 318         expect.assert_eq(&actual)
 319     }
 320
 321     #[test]
 322     fn postfix_completion_works_for_trivial_path_expression() {
 323         check(
 324             r#"
 325 fn main() {
 326     let bar = true;
 327     bar.$0
 328 }
 329 "#,
 330             expect![[r#"
 331                 sn if    if expr {}
 332                 sn while while expr {}
 333                 sn not   !expr
 334                 sn ref   &expr
 335                 sn refm  &mut expr
 336                 sn match match expr {}
 337                 sn box   Box::new(expr)
 338                 sn ok    Ok(expr)
 339                 sn err   Err(expr)
 340                 sn some  Some(expr)
 341                 sn dbg   dbg!(expr)
 342                 sn dbgr  dbg!(&expr)
 343                 sn call  function(expr)
 344                 sn let   let
 345                 sn letm  let mut
 346             "#]],
 347         );
 348     }
 349
 350     #[test]
 351     fn postfix_completion_works_for_function_calln() {
 352         check(
 353             r#"
 354 fn foo(elt: bool) -> bool {
 355     !elt
 356 }
 357
 358 fn main() {
 359     let bar = true;
 360     foo(bar.$0)
 361 }
 362 "#,
 363             expect![[r#"
 364                 sn if    if expr {}
 365                 sn while while expr {}
 366                 sn not   !expr
 367                 sn ref   &expr
 368                 sn refm  &mut expr
 369                 sn match match expr {}
 370                 sn box   Box::new(expr)
 371                 sn ok    Ok(expr)
 372                 sn err   Err(expr)
 373                 sn some  Some(expr)
 374                 sn dbg   dbg!(expr)
 375                 sn dbgr  dbg!(&expr)
 376                 sn call  function(expr)
 377             "#]],
 378         );
 379     }
 380
 381     #[test]
 382     fn postfix_type_filtering() {
 383         check(
 384             r#"
 385 fn main() {
 386     let bar: u8 = 12;
 387     bar.$0
 388 }
 389 "#,
 390             expect![[r#"
 391                 sn ref   &expr
 392                 sn refm  &mut expr
 393                 sn match match expr {}
 394                 sn box   Box::new(expr)
 395                 sn ok    Ok(expr)
 396                 sn err   Err(expr)
 397                 sn some  Some(expr)
 398                 sn dbg   dbg!(expr)
 399                 sn dbgr  dbg!(&expr)
 400                 sn call  function(expr)
 401                 sn let   let
 402                 sn letm  let mut
 403             "#]],
 404         )
 405     }
 406
 407     #[test]
 408     fn let_middle_block() {
 409         check(
 410             r#"
 411 fn main() {
 412     baz.l$0
 413     res
 414 }
 415 "#,
 416             expect![[r#"
 417                 sn if    if expr {}
 418                 sn while while expr {}
 419                 sn not   !expr
 420                 sn ref   &expr
 421                 sn refm  &mut expr
 422                 sn match match expr {}
 423                 sn box   Box::new(expr)
 424                 sn ok    Ok(expr)
 425                 sn err   Err(expr)
 426                 sn some  Some(expr)
 427                 sn dbg   dbg!(expr)
 428                 sn dbgr  dbg!(&expr)
 429                 sn call  function(expr)
 430                 sn let   let
 431                 sn letm  let mut
 432             "#]],
 433         );
 434     }
 435
 436     #[test]
 437     fn option_iflet() {
 438         check_edit(
 439             "ifl",
 440             r#"
 441 enum Option<T> { Some(T), None }
 442
 443 fn main() {
 444     let bar = Option::Some(true);
 445     bar.$0
 446 }
 447 "#,
 448             r#"
 449 enum Option<T> { Some(T), None }
 450
 451 fn main() {
 452     let bar = Option::Some(true);
 453     if let Some($1) = bar {
 454     $0
 455 }
 456 }
 457 "#,
 458         );
 459     }
 460
 461     #[test]
 462     fn result_match() {
 463         check_edit(
 464             "match",
 465             r#"
 466 enum Result<T, E> { Ok(T), Err(E) }
 467
 468 fn main() {
 469     let bar = Result::Ok(true);
 470     bar.$0
 471 }
 472 "#,
 473             r#"
 474 enum Result<T, E> { Ok(T), Err(E) }
 475
 476 fn main() {
 477     let bar = Result::Ok(true);
 478     match bar {
 479     Ok(${1:_}) => {$2},
 480     Err(${3:_}) => {$0},
 481 }
 482 }
 483 "#,
 484         );
 485     }
 486
 487     #[test]
 488     fn postfix_completion_works_for_ambiguous_float_literal() {
 489         check_edit("refm", r#"fn main() { 42.$0 }"#, r#"fn main() { &mut 42 }"#)
 490     }
 491
 492     #[test]
 493     fn works_in_simple_macro() {
 494         check_edit(
 495             "dbg",
 496             r#"
 497 macro_rules! m { ($e:expr) => { $e } }
 498 fn main() {
 499     let bar: u8 = 12;
 500     m!(bar.d$0)
 501 }
 502 "#,
 503             r#"
 504 macro_rules! m { ($e:expr) => { $e } }
 505 fn main() {
 506     let bar: u8 = 12;
 507     m!(dbg!(bar))
 508 }
 509 "#,
 510         );
 511     }
 512
 513     #[test]
 514     fn postfix_completion_for_references() {
 515         check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
 516         check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
 517         check_edit(
 518             "ifl",
 519             r#"
 520 enum Option<T> { Some(T), None }
 521
 522 fn main() {
 523     let bar = &Option::Some(true);
 524     bar.$0
 525 }
 526 "#,
 527             r#"
 528 enum Option<T> { Some(T), None }
 529
 530 fn main() {
 531     let bar = &Option::Some(true);
 532     if let Some($1) = bar {
 533     $0
 534 }
 535 }
 536 "#,
 537         )
 538     }
 539
 540     #[test]
 541     fn postfix_completion_for_format_like_strings() {
 542         check_edit(
 543             "format",
 544             r#"fn main() { "{some_var:?}".$0 }"#,
 545             r#"fn main() { format!("{:?}", some_var) }"#,
 546         );
 547         check_edit(
 548             "panic",
 549             r#"fn main() { "Panic with {a}".$0 }"#,
 550             r#"fn main() { panic!("Panic with {}", a) }"#,
 551         );
 552         check_edit(
 553             "println",
 554             r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".$0 }"#,
 555             r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
 556         );
 557         check_edit(
 558             "loge",
 559             r#"fn main() { "{2+2}".$0 }"#,
 560             r#"fn main() { log::error!("{}", 2+2) }"#,
 561         );
 562         check_edit(
 563             "logt",
 564             r#"fn main() { "{2+2}".$0 }"#,
 565             r#"fn main() { log::trace!("{}", 2+2) }"#,
 566         );
 567         check_edit(
 568             "logd",
 569             r#"fn main() { "{2+2}".$0 }"#,
 570             r#"fn main() { log::debug!("{}", 2+2) }"#,
 571         );
 572         check_edit("logi", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::info!("{}", 2+2) }"#);
 573         check_edit("logw", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::warn!("{}", 2+2) }"#);
 574         check_edit(
 575             "loge",
 576             r#"fn main() { "{2+2}".$0 }"#,
 577             r#"fn main() { log::error!("{}", 2+2) }"#,
 578         );
 579     }
 580 }