6 files changed, 100 insertions, 52 deletions

diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 2fe7c3de3..da2880037 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -105,7 +105,7 @@ impl<'a> AssistCtx<'a> {
         let mut info = AssistInfo::new(label);
         if self.should_compute_edit {
             let action = {
-                let mut edit = ActionBuilder::default();
+                let mut edit = ActionBuilder::new(&self);
                 f(&mut edit);
                 edit.build()
             };
@@ -130,6 +130,12 @@ impl<'a> AssistCtx<'a> {
     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 find_node_at_offset_with_descend<N: AstNode>(&self) -> Option<N> {
+        self.sema
+            .find_node_at_offset_with_descend(self.source_file.syntax(), self.frange.range.start())
+    }
+
     pub(crate) fn covering_element(&self) -> SyntaxElement {
         find_covering_element(self.source_file.syntax(), self.frange.range)
     }
@@ -156,7 +162,7 @@ impl<'a> AssistGroup<'a> {
         let mut info = AssistInfo::new(label).with_group(GroupLabel(self.group_name.clone()));
         if self.ctx.should_compute_edit {
             let action = {
-                let mut edit = ActionBuilder::default();
+                let mut edit = ActionBuilder::new(&self.ctx);
                 f(&mut edit);
                 edit.build()
             };
@@ -175,15 +181,29 @@ impl<'a> AssistGroup<'a> {
     }
 }
 
-#[derive(Default)]
-pub(crate) struct ActionBuilder {
+pub(crate) struct ActionBuilder<'a, 'b> {
     edit: TextEditBuilder,
     cursor_position: Option<TextSize>,
     target: Option<TextRange>,
     file: AssistFile,
+    ctx: &'a AssistCtx<'b>,
 }
 
-impl ActionBuilder {
+impl<'a, 'b> ActionBuilder<'a, 'b> {
+    fn new(ctx: &'a AssistCtx<'b>) -> Self {
+        Self {
+            edit: TextEditBuilder::default(),
+            cursor_position: None,
+            target: None,
+            file: AssistFile::default(),
+            ctx,
+        }
+    }
+
+    pub(crate) fn ctx(&self) -> &AssistCtx<'b> {
+        &self.ctx
+    }
+
     /// Replaces specified `range` of text with a given string.
     pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
         self.edit.replace(range, replace_with.into())
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 99682e023..db6c4d2fa 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -45,15 +45,12 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
         return None;
     }
 
+    let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
     let mut group = ctx.add_assist_group(auto_import_assets.get_import_group_message());
     for import in proposed_imports {
         group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
-            edit.target(auto_import_assets.syntax_under_caret.text_range());
-            insert_use_statement(
-                &auto_import_assets.syntax_under_caret,
-                &import,
-                edit.text_edit_builder(),
-            );
+            edit.target(range);
+            insert_use_statement(&auto_import_assets.syntax_under_caret, &import, edit);
         });
     }
     group.finish()
@@ -68,10 +65,10 @@ struct AutoImportAssets {
 
 impl AutoImportAssets {
     fn new(ctx: &AssistCtx) -> Option<Self> {
-        if let Some(path_under_caret) = ctx.find_node_at_offset::<ast::Path>() {
+        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
             Self::for_regular_path(path_under_caret, &ctx)
         } else {
-            Self::for_method_call(ctx.find_node_at_offset()?, &ctx)
+            Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx)
         }
     }
 
@@ -306,6 +303,35 @@ mod tests {
     }
 
     #[test]
+    fn applicable_when_found_an_import_in_macros() {
+        check_assist(
+            auto_import,
+            r"
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod::PubStruct;
+
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
     fn auto_imports_are_merged() {
         check_assist(
             auto_import,
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 918e8dd8d..ff2463c77 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -38,7 +38,7 @@ pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist>
         "Replace qualified path with use",
         |edit| {
             let path_to_import = hir_path.mod_path().clone();
-            insert_use_statement(path.syntax(), &path_to_import, edit.text_edit_builder());
+            insert_use_statement(path.syntax(), &path_to_import, edit);
 
             if let Some(last) = path.segment() {
                 // Here we are assuming the assist will provide a correct use statement
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index 58649c47e..859c70ad8 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -1,8 +1,8 @@
 use crate::{Assist, AssistCtx, AssistId};
 
-use ast::{BlockExpr, Expr, ForExpr, IfExpr, LoopBodyOwner, LoopExpr, WhileExpr};
+use ast::LoopBodyOwner;
 use ra_fmt::unwrap_trivial_block;
-use ra_syntax::{ast, AstNode, TextRange, T};
+use ra_syntax::{ast, match_ast, AstNode, TextRange, T};
 
 // Assist: unwrap_block
 //
@@ -23,39 +23,40 @@ use ra_syntax::{ast, AstNode, TextRange, T};
 // ```
 pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
     let l_curly_token = ctx.find_token_at_offset(T!['{'])?;
-
-    let res = if let Some(if_expr) = l_curly_token.ancestors().find_map(IfExpr::cast) {
-        // if expression
-        let expr_to_unwrap = if_expr.blocks().find_map(|expr| extract_expr(ctx.frange.range, expr));
-        let expr_to_unwrap = expr_to_unwrap?;
-        // Find if we are in a else if block
-        let ancestor = if_expr.syntax().ancestors().skip(1).find_map(ast::IfExpr::cast);
-
-        if let Some(ancestor) = ancestor {
-            Some((ast::Expr::IfExpr(ancestor), expr_to_unwrap))
-        } else {
-            Some((ast::Expr::IfExpr(if_expr), expr_to_unwrap))
+    let block = ast::BlockExpr::cast(l_curly_token.parent())?;
+    let parent = block.syntax().parent()?;
+    let (expr, expr_to_unwrap) = match_ast! {
+        match parent {
+            ast::IfExpr(if_expr) => {
+                let expr_to_unwrap = if_expr.blocks().find_map(|expr| extract_expr(ctx.frange.range, expr));
+                let expr_to_unwrap = expr_to_unwrap?;
+                // Find if we are in a else if block
+                let ancestor = if_expr.syntax().parent().and_then(ast::IfExpr::cast);
+
+                match ancestor {
+                    None => (ast::Expr::IfExpr(if_expr), expr_to_unwrap),
+                    Some(ancestor) => (ast::Expr::IfExpr(ancestor), expr_to_unwrap),
+                }
+            },
+            ast::ForExpr(for_expr) => {
+                let block_expr = for_expr.loop_body()?;
+                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
+                (ast::Expr::ForExpr(for_expr), expr_to_unwrap)
+            },
+            ast::WhileExpr(while_expr) => {
+                let block_expr = while_expr.loop_body()?;
+                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
+                (ast::Expr::WhileExpr(while_expr), expr_to_unwrap)
+            },
+            ast::LoopExpr(loop_expr) => {
+                let block_expr = loop_expr.loop_body()?;
+                let expr_to_unwrap = extract_expr(ctx.frange.range, block_expr)?;
+                (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap)
+            },
+            _ => return None,
         }
-    } else if let Some(for_expr) = l_curly_token.ancestors().find_map(ForExpr::cast) {
-        // for expression
-        let block_expr = for_expr.loop_body()?;
-        extract_expr(ctx.frange.range, block_expr)
-            .map(|expr_to_unwrap| (ast::Expr::ForExpr(for_expr), expr_to_unwrap))
-    } else if let Some(while_expr) = l_curly_token.ancestors().find_map(WhileExpr::cast) {
-        // while expression
-        let block_expr = while_expr.loop_body()?;
-        extract_expr(ctx.frange.range, block_expr)
-            .map(|expr_to_unwrap| (ast::Expr::WhileExpr(while_expr), expr_to_unwrap))
-    } else if let Some(loop_expr) = l_curly_token.ancestors().find_map(LoopExpr::cast) {
-        // loop expression
-        let block_expr = loop_expr.loop_body()?;
-        extract_expr(ctx.frange.range, block_expr)
-            .map(|expr_to_unwrap| (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap))
-    } else {
-        None
     };
 
-    let (expr, expr_to_unwrap) = res?;
     ctx.add_assist(AssistId("unwrap_block"), "Unwrap block", |edit| {
         edit.set_cursor(expr.syntax().text_range().start());
         edit.target(expr_to_unwrap.syntax().text_range());
@@ -76,7 +77,7 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
     })
 }
 
-fn extract_expr(cursor_range: TextRange, block: BlockExpr) -> Option<Expr> {
+fn extract_expr(cursor_range: TextRange, block: ast::BlockExpr) -> Option<ast::Expr> {
     let cursor_in_range = block.l_curly_token()?.text_range().contains_range(cursor_range);
 
     if cursor_in_range {
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index efd988697..6be704ce3 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
 
-pub use insert_use::insert_use_statement;
+pub(crate) use insert_use::insert_use_statement;
 
 pub fn get_missing_impl_items(
     sema: &Semantics<RootDatabase>,
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index c507e71e0..c1f447efe 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -2,6 +2,7 @@
 // FIXME: rewrite according to the plan, outlined in
 // https://github.com/rust-analyzer/rust-analyzer/issues/3301#issuecomment-592931553
 
+use crate::assist_ctx::ActionBuilder;
 use hir::{self, ModPath};
 use ra_syntax::{
     ast::{self, NameOwner},
@@ -14,14 +15,14 @@ use ra_text_edit::TextEditBuilder;
 /// Creates and inserts a use statement for the given path to import.
 /// The use statement is inserted in the scope most appropriate to the
 /// the cursor position given, additionally merged with the existing use imports.
-pub fn insert_use_statement(
+pub(crate) fn insert_use_statement(
     // Ideally the position of the cursor, used to
     position: &SyntaxNode,
     path_to_import: &ModPath,
-    edit: &mut TextEditBuilder,
+    edit: &mut ActionBuilder,
 ) {
     let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = position.ancestors().find_map(|n| {
+    let container = edit.ctx().sema.ancestors_with_macros(position.clone()).find_map(|n| {
         if let Some(module) = ast::Module::cast(n.clone()) {
             return module.item_list().map(|it| it.syntax().clone());
         }
@@ -30,7 +31,7 @@ pub fn insert_use_statement(
 
     if let Some(container) = container {
         let action = best_action_for_target(container, position.clone(), &target);
-        make_assist(&action, &target, edit);
+        make_assist(&action, &target, edit.text_edit_builder());
     }
 }