1 files changed, 61 insertions, 11 deletions

diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index 5c01654cc..919177745 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -1,7 +1,10 @@
 //! Runs completion for testing purposes.
 
 use hir::Semantics;
+use itertools::Itertools;
 use ra_syntax::{AstNode, NodeOrToken, SyntaxElement};
+use stdx::{format_to, trim_indent};
+use test_utils::assert_eq_text;
 
 use crate::{
     completion::{completion_item::CompletionKind, CompletionConfig},
@@ -10,15 +13,15 @@ use crate::{
 };
 
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    do_completion_with_options(code, kind, &CompletionConfig::default())
+    do_completion_with_config(CompletionConfig::default(), code, kind)
 }
 
-pub(crate) fn do_completion_with_options(
+pub(crate) fn do_completion_with_config(
+    config: CompletionConfig,
     code: &str,
     kind: CompletionKind,
-    options: &CompletionConfig,
 ) -> Vec<CompletionItem> {
-    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(code, options)
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(config, code)
         .into_iter()
         .filter(|c| c.completion_kind == kind)
         .collect();
@@ -27,25 +30,69 @@ pub(crate) fn do_completion_with_options(
 }
 
 pub(crate) fn completion_list(code: &str, kind: CompletionKind) -> String {
-    completion_list_with_options(code, kind, &CompletionConfig::default())
+    completion_list_with_config(CompletionConfig::default(), code, kind)
 }
 
-pub(crate) fn completion_list_with_options(
+pub(crate) fn completion_list_with_config(
+    config: CompletionConfig,
     code: &str,
     kind: CompletionKind,
-    options: &CompletionConfig,
 ) -> String {
-    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(code, options)
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(config, code)
         .into_iter()
         .filter(|c| c.completion_kind == kind)
         .collect();
     kind_completions.sort_by_key(|c| c.label().to_owned());
+    let label_width = kind_completions
+        .iter()
+        .map(|it| monospace_width(it.label()))
+        .max()
+        .unwrap_or_default()
+        .min(16);
     kind_completions
         .into_iter()
-        .map(|it| format!("{} {}\n", it.kind().unwrap().tag(), it.label()))
+        .map(|it| {
+            let tag = it.kind().unwrap().tag();
+            let var_name = format!("{} {}", tag, it.label());
+            let mut buf = var_name;
+            if let Some(detail) = it.detail() {
+                let width = label_width.saturating_sub(monospace_width(it.label()));
+                format_to!(buf, "{:width$} {}", "", detail, width = width);
+            }
+            format_to!(buf, "\n");
+            buf
+        })
         .collect()
 }
 
+fn monospace_width(s: &str) -> usize {
+    s.chars().count()
+}
+
+pub(crate) fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+    check_edit_with_config(CompletionConfig::default(), what, ra_fixture_before, ra_fixture_after)
+}
+
+pub(crate) fn check_edit_with_config(
+    config: CompletionConfig,
+    what: &str,
+    ra_fixture_before: &str,
+    ra_fixture_after: &str,
+) {
+    let ra_fixture_after = trim_indent(ra_fixture_after);
+    let (analysis, position) = analysis_and_position(ra_fixture_before);
+    let completions: Vec<CompletionItem> =
+        analysis.completions(&config, position).unwrap().unwrap().into();
+    let (completion,) = completions
+        .iter()
+        .filter(|it| it.lookup() == what)
+        .collect_tuple()
+        .unwrap_or_else(|| panic!("can't find {:?} completion in {:#?}", what, completions));
+    let mut actual = analysis.file_text(position.file_id).unwrap().to_string();
+    completion.text_edit().apply(&mut actual);
+    assert_eq_text!(&ra_fixture_after, &actual)
+}
+
 pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
     let (analysis, pos) = analysis_and_position(code);
     analysis
@@ -58,7 +105,10 @@ pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -
         .unwrap();
 }
 
-fn get_all_completion_items(code: &str, options: &CompletionConfig) -> Vec<CompletionItem> {
+pub(crate) fn get_all_completion_items(
+    config: CompletionConfig,
+    code: &str,
+) -> Vec<CompletionItem> {
     let (analysis, position) = analysis_and_position(code);
-    analysis.completions(options, position).unwrap().unwrap().into()
+    analysis.completions(&config, position).unwrap().unwrap().into()
 }