Merge branch 'master' into feature/themes

1 files changed, 24 insertions, 28 deletions

diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index e270c5d60..1908bdec9 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,11 +1,11 @@
-//! FIXME: write short doc here
+//! This module defines `AssistCtx` -- the API surface that is exposed to assists.
 
 use hir::db::HirDatabase;
 use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_syntax::{
     algo::{self, find_covering_element, find_node_at_offset},
-    AstNode, SourceFile, SyntaxElement, SyntaxNode, SyntaxToken, TextRange, TextUnit,
+    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextUnit,
     TokenAtOffset,
 };
 use ra_text_edit::TextEditBuilder;
@@ -14,8 +14,8 @@ use crate::{AssistAction, AssistId, AssistLabel};
 
 #[derive(Clone, Debug)]
 pub(crate) enum Assist {
-    Unresolved(Vec<AssistLabel>),
-    Resolved(Vec<(AssistLabel, AssistAction)>),
+    Unresolved { label: AssistLabel },
+    Resolved { label: AssistLabel, action: AssistAction },
 }
 
 /// `AssistCtx` allows to apply an assist or check if it could be applied.
@@ -54,7 +54,6 @@ pub(crate) struct AssistCtx<'a, DB> {
     pub(crate) frange: FileRange,
     source_file: SourceFile,
     should_compute_edit: bool,
-    assist: Assist,
 }
 
 impl<'a, DB> Clone for AssistCtx<'a, DB> {
@@ -64,7 +63,6 @@ impl<'a, DB> Clone for AssistCtx<'a, DB> {
             frange: self.frange,
             source_file: self.source_file.clone(),
             should_compute_edit: self.should_compute_edit,
-            assist: self.assist.clone(),
         }
     }
 }
@@ -75,43 +73,41 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
         F: FnOnce(AssistCtx<DB>) -> T,
     {
         let parse = db.parse(frange.file_id);
-        let assist =
-            if should_compute_edit { Assist::Resolved(vec![]) } else { Assist::Unresolved(vec![]) };
 
-        let ctx = AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit, assist };
+        let ctx = AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit };
         f(ctx)
     }
 
-    pub(crate) fn add_action(
-        &mut self,
+    pub(crate) fn add_assist(
+        self,
         id: AssistId,
         label: impl Into<String>,
         f: impl FnOnce(&mut AssistBuilder),
-    ) -> &mut Self {
+    ) -> Option<Assist> {
         let label = AssistLabel { label: label.into(), id };
-        match &mut self.assist {
-            Assist::Unresolved(labels) => labels.push(label),
-            Assist::Resolved(labels_actions) => {
-                let action = {
-                    let mut edit = AssistBuilder::default();
-                    f(&mut edit);
-                    edit.build()
-                };
-                labels_actions.push((label, action));
-            }
-        }
-        self
-    }
+        let assist = if self.should_compute_edit {
+            let action = {
+                let mut edit = AssistBuilder::default();
+                f(&mut edit);
+                edit.build()
+            };
+            Assist::Resolved { label, action }
+        } else {
+            Assist::Unresolved { label }
+        };
 
-    pub(crate) fn build(self) -> Option<Assist> {
-        Some(self.assist)
+        Some(assist)
     }
 
     pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
         self.source_file.syntax().token_at_offset(self.frange.range.start())
     }
 
-    pub(crate) fn node_at_offset<N: AstNode>(&self) -> Option<N> {
+    pub(crate) fn find_token_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
+        self.token_at_offset().find(|it| it.kind() == kind)
+    }
+
+    pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
         find_node_at_offset(self.source_file.syntax(), self.frange.range.start())
     }
     pub(crate) fn covering_element(&self) -> SyntaxElement {