2 files changed, 32 insertions, 157 deletions

diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 331a6df2b..fa378a622 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -17,156 +17,31 @@ mod tests;
 pub mod utils;
 pub mod path_transform;
 
-use std::str::FromStr;
-
 use hir::Semantics;
-use ide_db::{base_db::FileRange, label::Label, source_change::SourceChange, RootDatabase};
+use ide_db::{base_db::FileRange, RootDatabase};
 use syntax::TextRange;
 
 pub(crate) use crate::assist_context::{AssistContext, Assists};
 
 pub use assist_config::AssistConfig;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AssistKind {
-    // FIXME: does the None variant make sense? Probably not.
-    None,
-
-    QuickFix,
-    Generate,
-    Refactor,
-    RefactorExtract,
-    RefactorInline,
-    RefactorRewrite,
-}
-
-impl AssistKind {
-    pub fn contains(self, other: AssistKind) -> bool {
-        if self == other {
-            return true;
-        }
-
-        match self {
-            AssistKind::None | AssistKind::Generate => true,
-            AssistKind::Refactor => match other {
-                AssistKind::RefactorExtract
-                | AssistKind::RefactorInline
-                | AssistKind::RefactorRewrite => true,
-                _ => false,
-            },
-            _ => false,
-        }
-    }
-
-    pub fn name(&self) -> &str {
-        match self {
-            AssistKind::None => "None",
-            AssistKind::QuickFix => "QuickFix",
-            AssistKind::Generate => "Generate",
-            AssistKind::Refactor => "Refactor",
-            AssistKind::RefactorExtract => "RefactorExtract",
-            AssistKind::RefactorInline => "RefactorInline",
-            AssistKind::RefactorRewrite => "RefactorRewrite",
-        }
-    }
-}
-
-impl FromStr for AssistKind {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "None" => Ok(AssistKind::None),
-            "QuickFix" => Ok(AssistKind::QuickFix),
-            "Generate" => Ok(AssistKind::Generate),
-            "Refactor" => Ok(AssistKind::Refactor),
-            "RefactorExtract" => Ok(AssistKind::RefactorExtract),
-            "RefactorInline" => Ok(AssistKind::RefactorInline),
-            "RefactorRewrite" => Ok(AssistKind::RefactorRewrite),
-            unknown => Err(format!("Unknown AssistKind: '{}'", unknown)),
-        }
-    }
-}
-
-/// Unique identifier of the assist, should not be shown to the user
-/// directly.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct AssistId(pub &'static str, pub AssistKind);
-
-/// A way to control how many asssist to resolve during the assist resolution.
-/// When an assist is resolved, its edits are calculated that might be costly to always do by default.
-#[derive(Debug)]
-pub enum AssistResolveStrategy {
-    /// No assists should be resolved.
-    None,
-    /// All assists should be resolved.
-    All,
-    /// Only a certain assist should be resolved.
-    Single(SingleResolve),
-}
-
-/// Hold the [`AssistId`] data of a certain assist to resolve.
-/// The original id object cannot be used due to a `'static` lifetime
-/// and the requirement to construct this struct dynamically during the resolve handling.
-#[derive(Debug)]
-pub struct SingleResolve {
-    /// The id of the assist.
-    pub assist_id: String,
-    // The kind of the assist.
-    pub assist_kind: AssistKind,
-}
-
-impl AssistResolveStrategy {
-    pub fn should_resolve(&self, id: &AssistId) -> bool {
-        match self {
-            AssistResolveStrategy::None => false,
-            AssistResolveStrategy::All => true,
-            AssistResolveStrategy::Single(single_resolve) => {
-                single_resolve.assist_id == id.0 && single_resolve.assist_kind == id.1
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct GroupLabel(pub String);
-
-#[derive(Debug, Clone)]
-pub struct Assist {
-    pub id: AssistId,
-    /// Short description of the assist, as shown in the UI.
-    pub label: Label,
-    pub group: Option<GroupLabel>,
-    /// Target ranges are used to sort assists: the smaller the target range,
-    /// the more specific assist is, and so it should be sorted first.
-    pub target: TextRange,
-    /// Computing source change sometimes is much more costly then computing the
-    /// other fields. Additionally, the actual change is not required to show
-    /// the lightbulb UI, it only is needed when the user tries to apply an
-    /// assist. So, we compute it lazily: the API allow requesting assists with
-    /// or without source change. We could (and in fact, used to) distinguish
-    /// between resolved and unresolved assists at the type level, but this is
-    /// cumbersome, especially if you want to embed an assist into another data
-    /// structure, such as a diagnostic.
-    pub source_change: Option<SourceChange>,
-}
-
-impl Assist {
-    /// Return all the assists applicable at the given position.
-    pub fn get(
-        db: &RootDatabase,
-        config: &AssistConfig,
-        resolve: AssistResolveStrategy,
-        range: FileRange,
-    ) -> Vec<Assist> {
-        let sema = Semantics::new(db);
-        let ctx = AssistContext::new(sema, config, range);
-        let mut acc = Assists::new(&ctx, resolve);
-        handlers::all().iter().for_each(|handler| {
-            handler(&mut acc, &ctx);
-        });
-        acc.finish()
-    }
+pub use ide_db::assists::{
+    Assist, AssistId, AssistKind, AssistResolveStrategy, GroupLabel, SingleResolve,
+};
+
+/// Return all the assists applicable at the given position.
+pub fn assists(
+    db: &RootDatabase,
+    config: &AssistConfig,
+    resolve: AssistResolveStrategy,
+    range: FileRange,
+) -> Vec<Assist> {
+    let sema = Semantics::new(db);
+    let ctx = AssistContext::new(sema, config, range);
+    let mut acc = Assists::new(&ctx, resolve);
+    handlers::all().iter().for_each(|handler| {
+        handler(&mut acc, &ctx);
+    });
+    acc.finish()
 }
 
 mod handlers {
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index bdf9cb71c..60cecd94c 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -16,8 +16,8 @@ use syntax::TextRange;
 use test_utils::{assert_eq_text, extract_offset};
 
 use crate::{
-    handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, AssistResolveStrategy,
-    Assists, SingleResolve,
+    assists, handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind,
+    AssistResolveStrategy, Assists, SingleResolve,
 };
 
 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
@@ -78,14 +78,14 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
     let before = db.file_text(file_id).to_string();
     let frange = FileRange { file_id, range: selection.into() };
 
-    let assist = Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::All, frange)
+    let assist = assists(&db, &TEST_CONFIG, AssistResolveStrategy::All, frange)
         .into_iter()
         .find(|assist| assist.id.0 == assist_id)
         .unwrap_or_else(|| {
             panic!(
                 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
                 assist_id,
-                Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange)
+                assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange)
                     .into_iter()
                     .map(|assist| assist.id.0)
                     .collect::<Vec<_>>()
@@ -210,7 +210,7 @@ fn assist_order_field_struct() {
     let (before_cursor_pos, before) = extract_offset(before);
     let (db, file_id) = with_single_file(&before);
     let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
-    let assists = Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
+    let assists = assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
     let mut assists = assists.iter();
 
     assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
@@ -235,7 +235,7 @@ pub fn test_some_range(a: int) -> bool {
 "#,
     );
 
-    let assists = Assist::get(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
+    let assists = assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
     let expected = labels(&assists);
 
     expect![[r#"
@@ -264,7 +264,7 @@ pub fn test_some_range(a: int) -> bool {
         let mut cfg = TEST_CONFIG;
         cfg.allowed = Some(vec![AssistKind::Refactor]);
 
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         let expected = labels(&assists);
 
         expect![[r#"
@@ -279,7 +279,7 @@ pub fn test_some_range(a: int) -> bool {
     {
         let mut cfg = TEST_CONFIG;
         cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         let expected = labels(&assists);
 
         expect![[r#"
@@ -292,7 +292,7 @@ pub fn test_some_range(a: int) -> bool {
     {
         let mut cfg = TEST_CONFIG;
         cfg.allowed = Some(vec![AssistKind::QuickFix]);
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         let expected = labels(&assists);
 
         expect![[r#""#]].assert_eq(&expected);
@@ -317,7 +317,7 @@ pub fn test_some_range(a: int) -> bool {
     cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
 
     {
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::None, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
         assert_eq!(2, assists.len());
         let mut assists = assists.into_iter();
 
@@ -353,7 +353,7 @@ pub fn test_some_range(a: int) -> bool {
     }
 
     {
-        let assists = Assist::get(
+        let assists = assists(
             &db,
             &cfg,
             AssistResolveStrategy::Single(SingleResolve {
@@ -397,7 +397,7 @@ pub fn test_some_range(a: int) -> bool {
     }
 
     {
-        let assists = Assist::get(
+        let assists = assists(
             &db,
             &cfg,
             AssistResolveStrategy::Single(SingleResolve {
@@ -462,7 +462,7 @@ pub fn test_some_range(a: int) -> bool {
     }
 
     {
-        let assists = Assist::get(&db, &cfg, AssistResolveStrategy::All, frange);
+        let assists = assists(&db, &cfg, AssistResolveStrategy::All, frange);
         assert_eq!(2, assists.len());
         let mut assists = assists.into_iter();