Merge #574

574: refactor completions to use TextEdit instead of InsertText r=matklad a=gfreezy

1. migrate from `insertText` to `TextEdit` from `CompleteItem`
2. use `insta` to test completions

Co-authored-by: gfreezy <[email protected]>

1 files changed, 47 insertions, 118 deletions

diff --git a/crates/ra_ide_api/src/completion/complete_keyword.rs b/crates/ra_ide_api/src/completion/complete_keyword.rs
index d350f06ce..10ae01bc5 100644
--- a/crates/ra_ide_api/src/completion/complete_keyword.rs
+++ b/crates/ra_ide_api/src/completion/complete_keyword.rs
@@ -9,38 +9,36 @@ use crate::completion::{CompletionContext, CompletionItem, Completions, Completi
 
 pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     // complete keyword "crate" in use stmt
+    let source_range = ctx.source_range();
     match (ctx.use_item_syntax.as_ref(), ctx.path_prefix.as_ref()) {
         (Some(_), None) => {
-            CompletionItem::new(CompletionKind::Keyword, "crate")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "crate")
                 .kind(CompletionItemKind::Keyword)
-                .lookup_by("crate")
-                .snippet("crate::")
+                .insert_text("crate::")
                 .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, "self")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "self")
                 .kind(CompletionItemKind::Keyword)
-                .lookup_by("self")
                 .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, "super")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super")
                 .kind(CompletionItemKind::Keyword)
-                .lookup_by("super")
+                .insert_text("super::")
                 .add_to(acc);
         }
         (Some(_), Some(_)) => {
-            CompletionItem::new(CompletionKind::Keyword, "self")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "self")
                 .kind(CompletionItemKind::Keyword)
-                .lookup_by("self")
                 .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, "super")
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super")
                 .kind(CompletionItemKind::Keyword)
-                .lookup_by("super")
+                .insert_text("super::")
                 .add_to(acc);
         }
         _ => {}
     }
 }
 
-fn keyword(kw: &str, snippet: &str) -> CompletionItem {
-    CompletionItem::new(CompletionKind::Keyword, kw)
+fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
+    CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
         .kind(CompletionItemKind::Keyword)
         .snippet(snippet)
         .build()
@@ -55,25 +53,25 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         Some(it) => it,
         None => return,
     };
-    acc.add(keyword("if", "if $0 {}"));
-    acc.add(keyword("match", "match $0 {}"));
-    acc.add(keyword("while", "while $0 {}"));
-    acc.add(keyword("loop", "loop {$0}"));
+    acc.add(keyword(ctx, "if", "if $0 {}"));
+    acc.add(keyword(ctx, "match", "match $0 {}"));
+    acc.add(keyword(ctx, "while", "while $0 {}"));
+    acc.add(keyword(ctx, "loop", "loop {$0}"));
 
     if ctx.after_if {
-        acc.add(keyword("else", "else {$0}"));
-        acc.add(keyword("else if", "else if $0 {}"));
+        acc.add(keyword(ctx, "else", "else {$0}"));
+        acc.add(keyword(ctx, "else if", "else if $0 {}"));
     }
     if is_in_loop_body(ctx.leaf) {
         if ctx.can_be_stmt {
-            acc.add(keyword("continue", "continue;"));
-            acc.add(keyword("break", "break;"));
+            acc.add(keyword(ctx, "continue", "continue;"));
+            acc.add(keyword(ctx, "break", "break;"));
         } else {
-            acc.add(keyword("continue", "continue"));
-            acc.add(keyword("break", "break"));
+            acc.add(keyword(ctx, "continue", "continue"));
+            acc.add(keyword(ctx, "break", "break"));
         }
     }
-    acc.add_all(complete_return(fn_def, ctx.can_be_stmt));
+    acc.add_all(complete_return(ctx, fn_def, ctx.can_be_stmt));
 }
 
 fn is_in_loop_body(leaf: &SyntaxNode) -> bool {
@@ -95,78 +93,69 @@ fn is_in_loop_body(leaf: &SyntaxNode) -> bool {
     false
 }
 
-fn complete_return(fn_def: &ast::FnDef, can_be_stmt: bool) -> Option<CompletionItem> {
+fn complete_return(
+    ctx: &CompletionContext,
+    fn_def: &ast::FnDef,
+    can_be_stmt: bool,
+) -> Option<CompletionItem> {
     let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
         (true, true) => "return $0;",
         (true, false) => "return;",
         (false, true) => "return $0",
         (false, false) => "return",
     };
-    Some(keyword("return", snip))
+    Some(keyword(ctx, "return", snip))
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{CompletionKind, check_completion};
-    fn check_keyword_completion(code: &str, expected_completions: &str) {
-        check_completion(code, expected_completions, CompletionKind::Keyword);
+    use crate::completion::CompletionKind;
+    use crate::completion::completion_item::check_completion;
+
+    fn check_keyword_completion(name: &str, code: &str) {
+        check_completion(name, code, CompletionKind::Keyword);
     }
 
     #[test]
     fn completes_keywords_in_use_stmt() {
         check_keyword_completion(
+            "keywords_in_use_stmt1",
             r"
             use <|>
             ",
-            r#"
-            crate "crate" "crate::"
-            self "self"
-            super "super"
-            "#,
         );
 
         check_keyword_completion(
+            "keywords_in_use_stmt2",
             r"
             use a::<|>
             ",
-            r#"
-            self "self"
-            super "super"
-            "#,
         );
 
         check_keyword_completion(
+            "keywords_in_use_stmt3",
             r"
             use a::{b, <|>}
             ",
-            r#"
-            self "self"
-            super "super"
-            "#,
         );
     }
 
     #[test]
     fn completes_various_keywords_in_function() {
         check_keyword_completion(
+            "keywords_in_function1",
             r"
             fn quux() {
                 <|>
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return;"
-            "#,
         );
     }
 
     #[test]
     fn completes_else_after_if() {
         check_keyword_completion(
+            "keywords_in_function2",
             r"
             fn quux() {
                 if true {
@@ -174,55 +163,35 @@ mod tests {
                 } <|>
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            else "else {$0}"
-            else if "else if $0 {}"
-            return "return;"
-            "#,
         );
     }
 
     #[test]
     fn test_completion_return_value() {
         check_keyword_completion(
+            "keywords_in_function3",
             r"
             fn quux() -> i32 {
                 <|>
                 92
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0;"
-            "#,
         );
         check_keyword_completion(
+            "keywords_in_function4",
             r"
             fn quux() {
                 <|>
                 92
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return;"
-            "#,
         );
     }
 
     #[test]
     fn dont_add_semi_after_return_if_not_a_statement() {
         check_keyword_completion(
+            "dont_add_semi_after_return_if_not_a_statement",
             r"
             fn quux() -> i32 {
                 match () {
@@ -230,19 +199,13 @@ mod tests {
                 }
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0"
-            "#,
         );
     }
 
     #[test]
     fn last_return_in_block_has_semi() {
         check_keyword_completion(
+            "last_return_in_block_has_semi1",
             r"
             fn quux() -> i32 {
                 if condition {
@@ -250,15 +213,9 @@ mod tests {
                 }
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0;"
-            "#,
         );
         check_keyword_completion(
+            "last_return_in_block_has_semi2",
             r"
             fn quux() -> i32 {
                 if condition {
@@ -268,54 +225,35 @@ mod tests {
                 x
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0;"
-            "#,
         );
     }
 
     #[test]
     fn completes_break_and_continue_in_loops() {
         check_keyword_completion(
+            "completes_break_and_continue_in_loops1",
             r"
             fn quux() -> i32 {
                 loop { <|> }
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            continue "continue;"
-            break "break;"
-            return "return $0;"
-            "#,
         );
+
         // No completion: lambda isolates control flow
         check_keyword_completion(
+            "completes_break_and_continue_in_loops2",
             r"
             fn quux() -> i32 {
                 loop { || { <|> } }
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0;"
-            "#,
         );
     }
 
     #[test]
     fn no_semi_after_break_continue_in_expr() {
         check_keyword_completion(
+            "no_semi_after_break_continue_in_expr",
             r"
             fn f() {
                 loop {
@@ -325,15 +263,6 @@ mod tests {
                 }
             }
             ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            continue "continue"
-            break "break"
-            return "return"
-            "#,
         )
     }
 }