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