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::{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,
  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     let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty.strip_references());
  60     if let Some(try_enum) = &try_enum {
  61         match try_enum {
  62             TryEnum::Result => {
  63                 postfix_snippet(
  64                     "ifl",
  65                     "if let Ok {}",
  66                     &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
  67                 )
  68                 .add_to(acc);
  69
  70                 postfix_snippet(
  71                     "while",
  72                     "while let Ok {}",
  73                     &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
  74                 )
  75                 .add_to(acc);
  76             }
  77             TryEnum::Option => {
  78                 postfix_snippet(
  79                     "ifl",
  80                     "if let Some {}",
  81                     &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
  82                 )
  83                 .add_to(acc);
  84
  85                 postfix_snippet(
  86                     "while",
  87                     "while let Some {}",
  88                     &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
  89                 )
  90                 .add_to(acc);
  91             }
  92         }
  93     } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
  94         postfix_snippet("if", "if expr {}", &format!("if {} {{\n    $0\n}}", receiver_text))
  95             .add_to(acc);
  96         postfix_snippet(
  97             "while",
  98             "while expr {}",
  99             &format!("while {} {{\n    $0\n}}", receiver_text),
 100         )
 101         .add_to(acc);
 102         postfix_snippet("not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
 103     } else if let Some(trait_) = FamousDefs(&ctx.sema, ctx.krate).core_iter_IntoIterator() {
 104         if receiver_ty.impls_trait(ctx.db, trait_, &[]) {
 105             postfix_snippet(
 106                 "for",
 107                 "for ele in expr {}",
 108                 &format!("for ele in {} {{\n    $0\n}}", receiver_text),
 109             )
 110             .add_to(acc);
 111         }
 112     }
 113
 114     postfix_snippet("ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
 115     postfix_snippet("refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
 116
 117     // The rest of the postfix completions create an expression that moves an argument,
 118     // so it's better to consider references now to avoid breaking the compilation
 119     let dot_receiver = include_references(dot_receiver);
 120     let receiver_text = get_receiver_text(&dot_receiver, receiver_is_ambiguous_float_literal);
 121     let postfix_snippet = build_postfix_snippet_builder(ctx, cap, &dot_receiver);
 122
 123     match try_enum {
 124         Some(try_enum) => match try_enum {
 125             TryEnum::Result => {
 126                 postfix_snippet(
 127                     "match",
 128                     "match expr {}",
 129                     &format!("match {} {{\n    Ok(${{1:_}}) => {{$2}},\n    Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
 130                 )
 131                 .add_to(acc);
 132             }
 133             TryEnum::Option => {
 134                 postfix_snippet(
 135                     "match",
 136                     "match expr {}",
 137                     &format!(
 138                         "match {} {{\n    Some(${{1:_}}) => {{$2}},\n    None => {{$0}},\n}}",
 139                         receiver_text
 140                     ),
 141                 )
 142                 .add_to(acc);
 143             }
 144         },
 145         None => {
 146             postfix_snippet(
 147                 "match",
 148                 "match expr {}",
 149                 &format!("match {} {{\n    ${{1:_}} => {{$0}},\n}}", receiver_text),
 150             )
 151             .add_to(acc);
 152         }
 153     }
 154
 155     postfix_snippet("box", "Box::new(expr)", &format!("Box::new({})", receiver_text)).add_to(acc);
 156     postfix_snippet("ok", "Ok(expr)", &format!("Ok({})", receiver_text)).add_to(acc);
 157     postfix_snippet("err", "Err(expr)", &format!("Err({})", receiver_text)).add_to(acc);
 158     postfix_snippet("some", "Some(expr)", &format!("Some({})", receiver_text)).add_to(acc);
 159     postfix_snippet("dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
 160     postfix_snippet("dbgr", "dbg!(&expr)", &format!("dbg!(&{})", receiver_text)).add_to(acc);
 161     postfix_snippet("call", "function(expr)", &format!("${{1}}({})", receiver_text)).add_to(acc);
 162
 163     if let Some(parent) = dot_receiver.syntax().parent().and_then(|p| p.parent()) {
 164         if matches!(parent.kind(), STMT_LIST | EXPR_STMT) {
 165             postfix_snippet("let", "let", &format!("let $0 = {};", receiver_text)).add_to(acc);
 166             postfix_snippet("letm", "let mut", &format!("let mut $0 = {};", receiver_text))
 167                 .add_to(acc);
 168         }
 169     }
 170
 171     if let ast::Expr::Literal(literal) = dot_receiver.clone() {
 172         if let Some(literal_text) = ast::String::cast(literal.token()) {
 173             add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
 174         }
 175     }
 176 }
 177
 178 fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
 179     if receiver_is_ambiguous_float_literal {
 180         let text = receiver.syntax().text();
 181         let without_dot = ..text.len() - TextSize::of('.');
 182         text.slice(without_dot).to_string()
 183     } else {
 184         receiver.to_string()
 185     }
 186 }
 187
 188 fn include_references(initial_element: &ast::Expr) -> ast::Expr {
 189     let mut resulting_element = initial_element.clone();
 190     while let Some(parent_ref_element) =
 191         resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
 192     {
 193         resulting_element = ast::Expr::from(parent_ref_element);
 194     }
 195     resulting_element
 196 }
 197
 198 fn build_postfix_snippet_builder<'a>(
 199     ctx: &'a CompletionContext,
 200     cap: SnippetCap,
 201     receiver: &'a ast::Expr,
 202 ) -> impl Fn(&str, &str, &str) -> Builder + 'a {
 203     let receiver_syntax = receiver.syntax();
 204     let receiver_range = ctx.sema.original_range(receiver_syntax).range;
 205     let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
 206
 207     move |label, detail, snippet| {
 208         let edit = TextEdit::replace(delete_range, snippet.to_string());
 209         let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
 210         item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
 211         if ctx.original_token.text() == label {
 212             let relevance =
 213                 CompletionRelevance { exact_postfix_snippet_match: true, ..Default::default() };
 214             item.set_relevance(relevance);
 215         }
 216
 217         item
 218     }
 219 }
 220
 221 #[cfg(test)]
 222 mod tests {
 223     use expect_test::{expect, Expect};
 224
 225     use crate::{
 226         tests::{check_edit, filtered_completion_list},
 227         CompletionKind,
 228     };
 229
 230     fn check(ra_fixture: &str, expect: Expect) {
 231         let actual = filtered_completion_list(ra_fixture, CompletionKind::Postfix);
 232         expect.assert_eq(&actual)
 233     }
 234
 235     #[test]
 236     fn postfix_completion_works_for_trivial_path_expression() {
 237         check(
 238             r#"
 239 fn main() {
 240     let bar = true;
 241     bar.$0
 242 }
 243 "#,
 244             expect![[r#"
 245                 sn if    if expr {}
 246                 sn while while expr {}
 247                 sn not   !expr
 248                 sn ref   &expr
 249                 sn refm  &mut expr
 250                 sn match match expr {}
 251                 sn box   Box::new(expr)
 252                 sn ok    Ok(expr)
 253                 sn err   Err(expr)
 254                 sn some  Some(expr)
 255                 sn dbg   dbg!(expr)
 256                 sn dbgr  dbg!(&expr)
 257                 sn call  function(expr)
 258                 sn let   let
 259                 sn letm  let mut
 260             "#]],
 261         );
 262     }
 263
 264     #[test]
 265     fn postfix_completion_works_for_function_calln() {
 266         check(
 267             r#"
 268 fn foo(elt: bool) -> bool {
 269     !elt
 270 }
 271
 272 fn main() {
 273     let bar = true;
 274     foo(bar.$0)
 275 }
 276 "#,
 277             expect![[r#"
 278                 sn if    if expr {}
 279                 sn while while expr {}
 280                 sn not   !expr
 281                 sn ref   &expr
 282                 sn refm  &mut expr
 283                 sn match match expr {}
 284                 sn box   Box::new(expr)
 285                 sn ok    Ok(expr)
 286                 sn err   Err(expr)
 287                 sn some  Some(expr)
 288                 sn dbg   dbg!(expr)
 289                 sn dbgr  dbg!(&expr)
 290                 sn call  function(expr)
 291             "#]],
 292         );
 293     }
 294
 295     #[test]
 296     fn postfix_type_filtering() {
 297         check(
 298             r#"
 299 fn main() {
 300     let bar: u8 = 12;
 301     bar.$0
 302 }
 303 "#,
 304             expect![[r#"
 305                 sn ref   &expr
 306                 sn refm  &mut expr
 307                 sn match match expr {}
 308                 sn box   Box::new(expr)
 309                 sn ok    Ok(expr)
 310                 sn err   Err(expr)
 311                 sn some  Some(expr)
 312                 sn dbg   dbg!(expr)
 313                 sn dbgr  dbg!(&expr)
 314                 sn call  function(expr)
 315                 sn let   let
 316                 sn letm  let mut
 317             "#]],
 318         )
 319     }
 320
 321     #[test]
 322     fn let_middle_block() {
 323         check(
 324             r#"
 325 fn main() {
 326     baz.l$0
 327     res
 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 option_iflet() {
 352         check_edit(
 353             "ifl",
 354             r#"
 355 //- minicore: option
 356 fn main() {
 357     let bar = Some(true);
 358     bar.$0
 359 }
 360 "#,
 361             r#"
 362 fn main() {
 363     let bar = Some(true);
 364     if let Some($1) = bar {
 365     $0
 366 }
 367 }
 368 "#,
 369         );
 370     }
 371
 372     #[test]
 373     fn result_match() {
 374         check_edit(
 375             "match",
 376             r#"
 377 //- minicore: result
 378 fn main() {
 379     let bar = Ok(true);
 380     bar.$0
 381 }
 382 "#,
 383             r#"
 384 fn main() {
 385     let bar = Ok(true);
 386     match bar {
 387     Ok(${1:_}) => {$2},
 388     Err(${3:_}) => {$0},
 389 }
 390 }
 391 "#,
 392         );
 393     }
 394
 395     #[test]
 396     fn postfix_completion_works_for_ambiguous_float_literal() {
 397         check_edit("refm", r#"fn main() { 42.$0 }"#, r#"fn main() { &mut 42 }"#)
 398     }
 399
 400     #[test]
 401     fn works_in_simple_macro() {
 402         check_edit(
 403             "dbg",
 404             r#"
 405 macro_rules! m { ($e:expr) => { $e } }
 406 fn main() {
 407     let bar: u8 = 12;
 408     m!(bar.d$0)
 409 }
 410 "#,
 411             r#"
 412 macro_rules! m { ($e:expr) => { $e } }
 413 fn main() {
 414     let bar: u8 = 12;
 415     m!(dbg!(bar))
 416 }
 417 "#,
 418         );
 419     }
 420
 421     #[test]
 422     fn postfix_completion_for_references() {
 423         check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
 424         check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
 425         check_edit(
 426             "ifl",
 427             r#"
 428 //- minicore: option
 429 fn main() {
 430     let bar = &Some(true);
 431     bar.$0
 432 }
 433 "#,
 434             r#"
 435 fn main() {
 436     let bar = &Some(true);
 437     if let Some($1) = bar {
 438     $0
 439 }
 440 }
 441 "#,
 442         )
 443     }
 444
 445     #[test]
 446     fn postfix_completion_for_format_like_strings() {
 447         check_edit(
 448             "format",
 449             r#"fn main() { "{some_var:?}".$0 }"#,
 450             r#"fn main() { format!("{:?}", some_var) }"#,
 451         );
 452         check_edit(
 453             "panic",
 454             r#"fn main() { "Panic with {a}".$0 }"#,
 455             r#"fn main() { panic!("Panic with {}", a) }"#,
 456         );
 457         check_edit(
 458             "println",
 459             r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".$0 }"#,
 460             r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
 461         );
 462         check_edit(
 463             "loge",
 464             r#"fn main() { "{2+2}".$0 }"#,
 465             r#"fn main() { log::error!("{}", 2+2) }"#,
 466         );
 467         check_edit(
 468             "logt",
 469             r#"fn main() { "{2+2}".$0 }"#,
 470             r#"fn main() { log::trace!("{}", 2+2) }"#,
 471         );
 472         check_edit(
 473             "logd",
 474             r#"fn main() { "{2+2}".$0 }"#,
 475             r#"fn main() { log::debug!("{}", 2+2) }"#,
 476         );
 477         check_edit("logi", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::info!("{}", 2+2) }"#);
 478         check_edit("logw", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::warn!("{}", 2+2) }"#);
 479         check_edit(
 480             "loge",
 481             r#"fn main() { "{2+2}".$0 }"#,
 482             r#"fn main() { log::error!("{}", 2+2) }"#,
 483         );
 484     }
 485 }