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