1 //! Postfix completions, like `Ok(10).ifl$0` => `if let Ok() = Ok(10) { $0 }`.
6 helpers::{FamousDefs, SnippetCap},
10 ast::{self, AstNode, AstToken},
11 SyntaxKind::{BLOCK_EXPR, EXPR_STMT},
14 use text_edit::TextEdit;
17 completions::postfix::format_like::add_format_like_completions,
18 context::CompletionContext,
19 item::{Builder, CompletionKind},
20 patterns::ImmediateLocation,
21 CompletionItem, CompletionItemKind, CompletionRelevance, Completions,
24 pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
25 if !ctx.config.enable_postfix_completions {
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 {
33 receiver_is_ambiguous_float_literal,
34 }) => (it, *receiver_is_ambiguous_float_literal),
38 let receiver_text = get_receiver_text(dot_receiver, receiver_is_ambiguous_float_literal);
40 let receiver_ty = match ctx.sema.type_of_expr(dot_receiver) {
45 let cap = match ctx.config.snippet_cap {
49 let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty.strip_references());
50 if let Some(try_enum) = &try_enum {
59 &format!("if let Ok($1) = {} {{\n $0\n}}", receiver_text),
69 &format!("while let Ok($1) = {} {{\n $0\n}}", receiver_text),
80 &format!("if let Some($1) = {} {{\n $0\n}}", receiver_text),
90 &format!("while let Some($1) = {} {{\n $0\n}}", receiver_text),
95 } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
102 &format!("if {} {{\n $0\n}}", receiver_text),
111 &format!("while {} {{\n $0\n}}", receiver_text),
114 postfix_snippet(ctx, cap, dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
116 } else if let Some(trait_) = FamousDefs(&ctx.sema, ctx.krate).core_iter_IntoIterator() {
117 if receiver_ty.impls_trait(ctx.db, trait_, &[]) {
123 "for ele in expr {}",
124 &format!("for ele in {} {{\n $0\n}}", receiver_text),
130 postfix_snippet(ctx, cap, dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
138 &format!("&mut {}", receiver_text),
142 // The rest of the postfix completions create an expression that moves an argument,
143 // so it's better to consider references now to avoid breaking the compilation
144 let dot_receiver = include_references(dot_receiver);
145 let receiver_text = get_receiver_text(&dot_receiver, receiver_is_ambiguous_float_literal);
148 Some(try_enum) => match try_enum {
156 &format!("match {} {{\n Ok(${{1:_}}) => {{$2}},\n Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
168 "match {} {{\n Some(${{1:_}}) => {{$2}},\n None => {{$0}},\n}}",
182 &format!("match {} {{\n ${{1:_}} => {{$0}},\n}}", receiver_text),
194 &format!("Box::new({})", receiver_text),
198 postfix_snippet(ctx, cap, &dot_receiver, "ok", "Ok(expr)", &format!("Ok({})", receiver_text))
207 &format!("Err({})", receiver_text),
217 &format!("Some({})", receiver_text),
227 &format!("dbg!({})", receiver_text),
237 &format!("dbg!(&{})", receiver_text),
247 &format!("${{1}}({})", receiver_text),
251 if let Some(parent) = dot_receiver.syntax().parent().and_then(|p| p.parent()) {
252 if matches!(parent.kind(), BLOCK_EXPR | EXPR_STMT) {
259 &format!("let $0 = {};", receiver_text),
268 &format!("let mut $0 = {};", receiver_text),
274 if let ast::Expr::Literal(literal) = dot_receiver.clone() {
275 if let Some(literal_text) = ast::String::cast(literal.token()) {
276 add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
281 fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
282 if receiver_is_ambiguous_float_literal {
283 let text = receiver.syntax().text();
284 let without_dot = ..text.len() - TextSize::of('.');
285 text.slice(without_dot).to_string()
291 fn include_references(initial_element: &ast::Expr) -> ast::Expr {
292 let mut resulting_element = initial_element.clone();
293 while let Some(parent_ref_element) =
294 resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
296 resulting_element = ast::Expr::from(parent_ref_element);
302 ctx: &CompletionContext,
304 receiver: &ast::Expr,
310 let receiver_syntax = receiver.syntax();
311 let receiver_range = ctx.sema.original_range(receiver_syntax).range;
312 let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
313 TextEdit::replace(delete_range, snippet.to_string())
315 let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
316 item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
317 if ctx.original_token.text() == label {
318 let mut relevance = CompletionRelevance::default();
319 relevance.exact_postfix_snippet_match = true;
320 item.set_relevance(relevance);
328 use expect_test::{expect, Expect};
331 tests::{check_edit, filtered_completion_list},
335 fn check(ra_fixture: &str, expect: Expect) {
336 let actual = filtered_completion_list(ra_fixture, CompletionKind::Postfix);
337 expect.assert_eq(&actual)
341 fn postfix_completion_works_for_trivial_path_expression() {
351 sn while while expr {}
355 sn match match expr {}
356 sn box Box::new(expr)
362 sn call function(expr)
370 fn postfix_completion_works_for_function_calln() {
373 fn foo(elt: bool) -> bool {
384 sn while while expr {}
388 sn match match expr {}
389 sn box Box::new(expr)
395 sn call function(expr)
401 fn postfix_type_filtering() {
412 sn match match expr {}
413 sn box Box::new(expr)
419 sn call function(expr)
427 fn let_middle_block() {
437 sn while while expr {}
441 sn match match expr {}
442 sn box Box::new(expr)
448 sn call function(expr)
462 let bar = Some(true);
468 let bar = Some(true);
469 if let Some($1) = bar {
501 fn postfix_completion_works_for_ambiguous_float_literal() {
502 check_edit("refm", r#"fn main() { 42.$0 }"#, r#"fn main() { &mut 42 }"#)
506 fn works_in_simple_macro() {
510 macro_rules! m { ($e:expr) => { $e } }
517 macro_rules! m { ($e:expr) => { $e } }
527 fn postfix_completion_for_references() {
528 check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
529 check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
535 let bar = &Some(true);
541 let bar = &Some(true);
542 if let Some($1) = bar {
551 fn postfix_completion_for_format_like_strings() {
554 r#"fn main() { "{some_var:?}".$0 }"#,
555 r#"fn main() { format!("{:?}", some_var) }"#,
559 r#"fn main() { "Panic with {a}".$0 }"#,
560 r#"fn main() { panic!("Panic with {}", a) }"#,
564 r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".$0 }"#,
565 r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
569 r#"fn main() { "{2+2}".$0 }"#,
570 r#"fn main() { log::error!("{}", 2+2) }"#,
574 r#"fn main() { "{2+2}".$0 }"#,
575 r#"fn main() { log::trace!("{}", 2+2) }"#,
579 r#"fn main() { "{2+2}".$0 }"#,
580 r#"fn main() { log::debug!("{}", 2+2) }"#,
582 check_edit("logi", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::info!("{}", 2+2) }"#);
583 check_edit("logw", r#"fn main() { "{2+2}".$0 }"#, r#"fn main() { log::warn!("{}", 2+2) }"#);
586 r#"fn main() { "{2+2}".$0 }"#,
587 r#"fn main() { log::error!("{}", 2+2) }"#,