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