1 files changed, 122 insertions, 88 deletions

diff --git a/crates/ra_ide_api/src/completion/completion_item.rs b/crates/ra_ide_api/src/completion/completion_item.rs
index 11d00f78c..7bd634498 100644
--- a/crates/ra_ide_api/src/completion/completion_item.rs
+++ b/crates/ra_ide_api/src/completion/completion_item.rs
@@ -1,6 +1,10 @@
 use hir::PerNs;
+use ra_text_edit::{
+    AtomTextEdit,
+    TextEdit,
+};
 
-use crate::completion::CompletionContext;
+use crate::completion::completion_context::CompletionContext;
 
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
@@ -11,15 +15,29 @@ pub struct CompletionItem {
     /// completion.
     completion_kind: CompletionKind,
     label: String,
+    kind: Option<CompletionItemKind>,
     detail: Option<String>,
     lookup: Option<String>,
-    snippet: Option<String>,
-    kind: Option<CompletionItemKind>,
-}
-
-pub enum InsertText {
-    PlainText { text: String },
-    Snippet { text: String },
+    /// The format of the insert text. The format applies to both the `insert_text` property
+    /// and the `insert` property of a provided `text_edit`.
+    insert_text_format: InsertTextFormat,
+    /// An edit which is applied to a document when selecting this completion. When an edit is
+    /// provided the value of `insert_text` is ignored.
+    ///
+    /// *Note:* The range of the edit must be a single line range and it must contain the position
+    /// at which completion has been requested.
+    ///
+    /// *Note:* If sending a range that overlaps a string, the string should match the relevant
+    /// part of the replacement text, or be filtered out.
+    text_edit: Option<AtomTextEdit>,
+    /// An optional array of additional text edits that are applied when
+    /// selecting this completion. Edits must not overlap (including the same insert position)
+    /// with the main edit nor with themselves.
+    ///
+    /// Additional text edits should be used to change text unrelated to the current cursor position
+    /// (for example adding an import statement at the top of the file if the completion item will
+    /// insert an unqualified type).
+    additional_text_edits: Option<TextEdit>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -40,7 +58,7 @@ pub enum CompletionItemKind {
     Method,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub(crate) enum CompletionKind {
     /// Parser-based keyword completion.
     Keyword,
@@ -51,16 +69,30 @@ pub(crate) enum CompletionKind {
     Snippet,
 }
 
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum InsertTextFormat {
+    PlainText,
+    Snippet,
+}
+
 impl CompletionItem {
-    pub(crate) fn new(completion_kind: CompletionKind, label: impl Into<String>) -> Builder {
+    pub(crate) fn new<'a>(
+        completion_kind: CompletionKind,
+        ctx: &'a CompletionContext,
+        label: impl Into<String>,
+    ) -> Builder<'a> {
         let label = label.into();
         Builder {
+            ctx,
             completion_kind,
             label,
+            insert_text: None,
+            insert_text_format: InsertTextFormat::PlainText,
             detail: None,
             lookup: None,
-            snippet: None,
             kind: None,
+            text_edit: None,
+            additional_text_edits: None,
         }
     }
     /// What user sees in pop-up in the UI.
@@ -78,64 +110,100 @@ impl CompletionItem {
             .map(|it| it.as_str())
             .unwrap_or(self.label())
     }
-    /// What is inserted.
-    pub fn insert_text(&self) -> InsertText {
-        match &self.snippet {
-            None => InsertText::PlainText {
-                text: self.label.clone(),
-            },
-            Some(it) => InsertText::Snippet { text: it.clone() },
-        }
+
+    pub fn insert_text_format(&self) -> InsertTextFormat {
+        self.insert_text_format.clone()
     }
 
     pub fn kind(&self) -> Option<CompletionItemKind> {
         self.kind
     }
+    pub fn text_edit(&mut self) -> Option<&AtomTextEdit> {
+        self.text_edit.as_ref()
+    }
+    pub fn take_additional_text_edits(&mut self) -> Option<TextEdit> {
+        self.additional_text_edits.take()
+    }
 }
 
 /// A helper to make `CompletionItem`s.
 #[must_use]
-pub(crate) struct Builder {
+pub(crate) struct Builder<'a> {
+    ctx: &'a CompletionContext<'a>,
     completion_kind: CompletionKind,
     label: String,
+    insert_text: Option<String>,
+    insert_text_format: InsertTextFormat,
     detail: Option<String>,
     lookup: Option<String>,
-    snippet: Option<String>,
     kind: Option<CompletionItemKind>,
+    text_edit: Option<AtomTextEdit>,
+    additional_text_edits: Option<TextEdit>,
 }
 
-impl Builder {
+impl<'a> Builder<'a> {
     pub(crate) fn add_to(self, acc: &mut Completions) {
         acc.add(self.build())
     }
 
     pub(crate) fn build(self) -> CompletionItem {
+        let self_text_edit = self.text_edit;
+        let self_insert_text = self.insert_text;
+        let text_edit = match (self_text_edit, self_insert_text) {
+            (Some(text_edit), ..) => Some(text_edit),
+            (None, Some(insert_text)) => {
+                Some(AtomTextEdit::replace(self.ctx.leaf_range(), insert_text))
+            }
+            _ => None,
+        };
+
         CompletionItem {
             label: self.label,
             detail: self.detail,
+            insert_text_format: self.insert_text_format,
             lookup: self.lookup,
-            snippet: self.snippet,
             kind: self.kind,
             completion_kind: self.completion_kind,
+            text_edit,
+            additional_text_edits: self.additional_text_edits,
         }
     }
-    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
+    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder<'a> {
         self.lookup = Some(lookup.into());
         self
     }
-    pub(crate) fn snippet(mut self, snippet: impl Into<String>) -> Builder {
-        self.snippet = Some(snippet.into());
+    pub(crate) fn insert_text(mut self, insert_text: impl Into<String>) -> Builder<'a> {
+        self.insert_text = Some(insert_text.into());
+        self
+    }
+    pub(crate) fn insert_text_format(
+        mut self,
+        insert_text_format: InsertTextFormat,
+    ) -> Builder<'a> {
+        self.insert_text_format = insert_text_format;
         self
     }
-    pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder {
+    pub(crate) fn snippet(mut self, snippet: impl Into<String>) -> Builder<'a> {
+        self.insert_text_format = InsertTextFormat::Snippet;
+        self.insert_text(snippet)
+    }
+    pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder<'a> {
         self.kind = Some(kind);
         self
     }
+    pub(crate) fn text_edit(mut self, text_edit: AtomTextEdit) -> Builder<'a> {
+        self.text_edit = Some(text_edit);
+        self
+    }
+    pub(crate) fn additional_text_edits(mut self, additional_text_edits: TextEdit) -> Builder<'a> {
+        self.additional_text_edits = Some(additional_text_edits);
+        self
+    }
     #[allow(unused)]
-    pub(crate) fn detail(self, detail: impl Into<String>) -> Builder {
+    pub(crate) fn detail(self, detail: impl Into<String>) -> Builder<'a> {
         self.set_detail(Some(detail))
     }
-    pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
+    pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder<'a> {
         self.detail = detail.map(Into::into);
         self
     }
@@ -143,7 +211,7 @@ impl Builder {
         mut self,
         ctx: &CompletionContext,
         resolution: &hir::Resolution,
-    ) -> Builder {
+    ) -> Builder<'a> {
         let resolved = resolution.def_id.map(|d| d.resolve(ctx.db));
         let kind = match resolved {
             PerNs {
@@ -188,21 +256,22 @@ impl Builder {
         mut self,
         ctx: &CompletionContext,
         function: hir::Function,
-    ) -> Builder {
+    ) -> Builder<'a> {
         // If not an import, add parenthesis automatically.
         if ctx.use_item_syntax.is_none() && !ctx.is_call {
             if function.signature(ctx.db).params().is_empty() {
-                self.snippet = Some(format!("{}()$0", self.label));
+                self.insert_text = Some(format!("{}()$0", self.label));
             } else {
-                self.snippet = Some(format!("{}($0)", self.label));
+                self.insert_text = Some(format!("{}($0)", self.label));
             }
+            self.insert_text_format = InsertTextFormat::Snippet;
         }
         self.kind = Some(CompletionItemKind::Function);
         self
     }
 }
 
-impl Into<CompletionItem> for Builder {
+impl<'a> Into<CompletionItem> for Builder<'a> {
     fn into(self) -> CompletionItem {
         self.build()
     }
@@ -225,60 +294,6 @@ impl Completions {
     {
         items.into_iter().for_each(|item| self.add(item.into()))
     }
-
-    #[cfg(test)]
-    pub(crate) fn assert_match(&self, expected: &str, kind: CompletionKind) {
-        let expected = normalize(expected);
-        let actual = self.debug_render(kind);
-        test_utils::assert_eq_text!(expected.as_str(), actual.as_str(),);
-
-        /// Normalize the textual representation of `Completions`:
-        /// replace `;` with newlines, normalize whitespace
-        fn normalize(expected: &str) -> String {
-            use ra_syntax::{tokenize, TextUnit, TextRange, SyntaxKind::SEMI};
-            let mut res = String::new();
-            for line in expected.trim().lines() {
-                let line = line.trim();
-                let mut start_offset: TextUnit = 0.into();
-                // Yep, we use rust tokenize in completion tests :-)
-                for token in tokenize(line) {
-                    let range = TextRange::offset_len(start_offset, token.len);
-                    start_offset += token.len;
-                    if token.kind == SEMI {
-                        res.push('\n');
-                    } else {
-                        res.push_str(&line[range]);
-                    }
-                }
-
-                res.push('\n');
-            }
-            res
-        }
-    }
-
-    #[cfg(test)]
-    fn debug_render(&self, kind: CompletionKind) -> String {
-        let mut res = String::new();
-        for c in self.buf.iter() {
-            if c.completion_kind == kind {
-                if let Some(lookup) = &c.lookup {
-                    res.push_str(lookup);
-                    res.push_str(&format!(" {:?}", c.label));
-                } else {
-                    res.push_str(&c.label);
-                }
-                if let Some(detail) = &c.detail {
-                    res.push_str(&format!(" {:?}", detail));
-                }
-                if let Some(snippet) = &c.snippet {
-                    res.push_str(&format!(" {:?}", snippet));
-                }
-                res.push('\n');
-            }
-        }
-        res
-    }
 }
 
 impl Into<Vec<CompletionItem>> for Completions {
@@ -286,3 +301,22 @@ impl Into<Vec<CompletionItem>> for Completions {
         self.buf
     }
 }
+
+#[cfg(test)]
+pub(crate) fn check_completion(test_name: &str, code: &str, kind: CompletionKind) {
+    use crate::mock_analysis::{single_file_with_position, analysis_and_position};
+    use crate::completion::completions;
+    use insta::assert_debug_snapshot_matches;
+    let (analysis, position) = if code.contains("//-") {
+        analysis_and_position(code)
+    } else {
+        single_file_with_position(code)
+    };
+    let completions = completions(&analysis.db, position).unwrap();
+    let completion_items: Vec<CompletionItem> = completions.into();
+    let kind_completions: Vec<CompletionItem> = completion_items
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
+    assert_debug_snapshot_matches!(test_name, kind_completions);
+}