10 files changed, 63 insertions, 123 deletions

diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index ffdcdc930..7a4d71e91 100644
--- a/crates/ide_completion/src/completions.rs
+++ b/crates/ide_completion/src/completions.rs
@@ -6,7 +6,6 @@ pub(crate) mod flyimport;
 pub(crate) mod fn_param;
 pub(crate) mod keyword;
 pub(crate) mod lifetime;
-pub(crate) mod macro_in_item_position;
 pub(crate) mod mod_;
 pub(crate) mod pattern;
 pub(crate) mod postfix;
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 0ca97a0e4..ba13d3707 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -5,8 +5,8 @@ use std::iter;
 use syntax::{SyntaxKind, T};
 
 use crate::{
-    patterns::ImmediateLocation, CompletionContext, CompletionItem, CompletionItemKind,
-    CompletionKind, Completions,
+    context::PathCompletionContext, patterns::ImmediateLocation, CompletionContext, CompletionItem,
+    CompletionItemKind, CompletionKind, Completions,
 };
 
 pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
@@ -128,8 +128,15 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         add_keyword("mut", "mut ");
     }
 
-    if ctx.in_loop_body {
-        if ctx.can_be_stmt() {
+    let (can_be_stmt, in_loop_body) = match ctx.path_context {
+        Some(PathCompletionContext {
+            is_trivial_path: true, can_be_stmt, in_loop_body, ..
+        }) => (can_be_stmt, in_loop_body),
+        _ => return,
+    };
+
+    if in_loop_body {
+        if can_be_stmt {
             add_keyword("continue", "continue;");
             add_keyword("break", "break;");
         } else {
@@ -138,9 +145,6 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         }
     }
 
-    if !ctx.is_trivial_path() {
-        return;
-    }
     let fn_def = match &ctx.function_def {
         Some(it) => it,
         None => return,
@@ -148,7 +152,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
 
     add_keyword(
         "return",
-        match (ctx.can_be_stmt(), fn_def.ret_type().is_some()) {
+        match (can_be_stmt, fn_def.ret_type().is_some()) {
             (true, true) => "return $0;",
             (true, false) => "return;",
             (false, true) => "return $0",
diff --git a/crates/ide_completion/src/completions/macro_in_item_position.rs b/crates/ide_completion/src/completions/macro_in_item_position.rs
deleted file mode 100644
index 781b96ff1..000000000
--- a/crates/ide_completion/src/completions/macro_in_item_position.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//! Completes macro invocations used in item position.
-
-use crate::{CompletionContext, Completions};
-
-// Ideally this should be removed and moved into `(un)qualified_path` respectively
-pub(crate) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
-    // Show only macros in top level.
-    if !ctx.expects_item() {
-        return;
-    }
-
-    ctx.scope.process_all_names(&mut |name, res| {
-        if let hir::ScopeDef::MacroDef(mac) = res {
-            acc.add_macro(ctx, Some(name.clone()), mac);
-        }
-        // FIXME: This should be done in qualified_path/unqualified_path instead?
-        if let hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
-            acc.add_resolution(ctx, name, &res);
-        }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use expect_test::{expect, Expect};
-
-    use crate::{test_utils::completion_list, CompletionKind};
-
-    fn check(ra_fixture: &str, expect: Expect) {
-        let actual = completion_list(ra_fixture, CompletionKind::Reference);
-        expect.assert_eq(&actual)
-    }
-
-    #[test]
-    fn completes_macros_as_item() {
-        check(
-            r#"
-macro_rules! foo { () => {} }
-fn foo() {}
-
-$0
-"#,
-            expect![[r#"
-                ma foo!(…) macro_rules! foo
-            "#]],
-        )
-    }
-}
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index c072de7b5..d58745fb4 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -7,7 +7,7 @@ use syntax::AstNode;
 use crate::{CompletionContext, Completions};
 
 pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    if ctx.is_path_disallowed() || ctx.expects_item() {
+    if ctx.is_path_disallowed() {
         return;
     }
     let path = match ctx.path_qual() {
@@ -20,7 +20,8 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         None => return,
     };
     let context_module = ctx.scope.module();
-    if ctx.expects_assoc_item() {
+
+    if ctx.expects_item() || ctx.expects_assoc_item() {
         if let hir::PathResolution::Def(hir::ModuleDef::Module(module)) = resolution {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
@@ -631,17 +632,17 @@ impl MyStruct {
 "#,
             expect![[r##"
                 md bar
-                ma foo! #[macro_export] macro_rules! foo
+                ma foo!(…) #[macro_export] macro_rules! foo
             "##]],
         );
     }
 
     #[test]
-    #[ignore] // FIXME doesn't complete anything atm
     fn completes_in_item_list() {
         check(
             r#"
 struct MyStruct {}
+#[macro_export]
 macro_rules! foo {}
 mod bar {}
 
@@ -649,7 +650,7 @@ crate::$0
 "#,
             expect![[r#"
                 md bar
-                ma foo! macro_rules! foo
+                ma foo!(…) #[macro_export] macro_rules! foo
             "#]],
         )
     }
diff --git a/crates/ide_completion/src/completions/snippet.rs b/crates/ide_completion/src/completions/snippet.rs
index 59a338e7b..b9862de67 100644
--- a/crates/ide_completion/src/completions/snippet.rs
+++ b/crates/ide_completion/src/completions/snippet.rs
@@ -3,8 +3,8 @@
 use ide_db::helpers::SnippetCap;
 
 use crate::{
-    item::Builder, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
-    Completions,
+    context::PathCompletionContext, item::Builder, CompletionContext, CompletionItem,
+    CompletionItemKind, CompletionKind, Completions,
 };
 
 fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
@@ -14,15 +14,21 @@ fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str)
 }
 
 pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path() && ctx.function_def.is_some()) {
+    if ctx.function_def.is_none() {
         return;
     }
+
+    let can_be_stmt = match ctx.path_context {
+        Some(PathCompletionContext { is_trivial_path: true, can_be_stmt, .. }) => can_be_stmt,
+        _ => return,
+    };
+
     let cap = match ctx.config.snippet_cap {
         Some(it) => it,
         None => return,
     };
 
-    if ctx.can_be_stmt() {
+    if can_be_stmt {
         snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
         snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
     }
diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs
index 968c0254d..a60e5f43c 100644
--- a/crates/ide_completion/src/completions/trait_impl.rs
+++ b/crates/ide_completion/src/completions/trait_impl.rs
@@ -34,20 +34,13 @@
 use hir::{self, HasAttrs, HasSource};
 use ide_db::{traits::get_missing_assoc_items, SymbolKind};
 use syntax::{
-    ast::{self, edit, Impl},
+    ast::{self, edit},
     display::function_declaration,
-    AstNode, SyntaxElement, SyntaxKind, SyntaxNode, TextRange, T,
+    AstNode, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, T,
 };
 use text_edit::TextEdit;
 
-use crate::{
-    CompletionContext,
-    CompletionItem,
-    CompletionItemKind,
-    CompletionKind,
-    Completions,
-    // display::function_declaration,
-};
+use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 
 #[derive(Debug, PartialEq, Eq)]
 enum ImplCompletionKind {
@@ -58,7 +51,7 @@ enum ImplCompletionKind {
 }
 
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
-    if let Some((kind, trigger, impl_def)) = completion_match(ctx) {
+    if let Some((kind, trigger, impl_def)) = completion_match(ctx.token.clone()) {
         get_missing_assoc_items(&ctx.sema, &impl_def).into_iter().for_each(|item| match item {
             hir::AssocItem::Function(fn_item)
                 if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Fn =>
@@ -80,8 +73,7 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
     }
 }
 
-fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, SyntaxNode, Impl)> {
-    let mut token = ctx.token.clone();
+fn completion_match(mut token: SyntaxToken) -> Option<(ImplCompletionKind, SyntaxNode, ast::Impl)> {
     // For keyword without name like `impl .. { fn $0 }`, the current position is inside
     // the whitespace token, which is outside `FN` syntax node.
     // We need to follow the previous token in this case.
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index f321ed52b..8b22933e0 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -5,26 +5,25 @@ use hir::ScopeDef;
 use crate::{CompletionContext, Completions};
 
 pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path() {
-        return;
-    }
-    if ctx.is_path_disallowed() || ctx.expects_item() {
+    if ctx.is_path_disallowed() || !ctx.is_trivial_path() {
         return;
     }
 
-    if ctx.expects_assoc_item() {
-        ctx.scope.process_all_names(&mut |name, def| {
-            if let ScopeDef::MacroDef(macro_def) = def {
-                acc.add_macro(ctx, Some(name.clone()), macro_def);
+    if ctx.expects_item() || ctx.expects_assoc_item() {
+        // only show macros in {Assoc}ItemList
+        ctx.scope.process_all_names(&mut |name, res| {
+            if let hir::ScopeDef::MacroDef(mac) = res {
+                acc.add_macro(ctx, Some(name.clone()), mac);
             }
-            if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = def {
-                acc.add_resolution(ctx, name, &def);
+            if let hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
+                acc.add_resolution(ctx, name, &res);
             }
         });
         return;
     }
 
     if ctx.expects_use_tree() {
+        // only show modules in a fresh UseTree
         cov_mark::hit!(only_completes_modules_in_import);
         ctx.scope.process_all_names(&mut |name, res| {
             if let ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) = res {
@@ -693,12 +692,11 @@ impl MyStruct {
 "#,
             expect![[r#"
                 md bar
-                ma foo! macro_rules! foo
+                ma foo!(…) macro_rules! foo
             "#]],
         )
     }
 
-    // FIXME: The completions here currently come from `macro_in_item_position`, but they shouldn't
     #[test]
     fn completes_in_item_list() {
         check(
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 20e033d31..6177caa12 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -43,6 +43,7 @@ pub(crate) struct PathCompletionContext {
     pub(super) can_be_stmt: bool,
     /// `true` if we expect an expression at the cursor position.
     pub(super) is_expr: bool,
+    pub(super) in_loop_body: bool,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -67,14 +68,13 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) krate: Option<hir::Crate>,
     pub(super) expected_name: Option<NameOrNameRef>,
     pub(super) expected_type: Option<Type>,
-    pub(super) name_ref_syntax: Option<ast::NameRef>,
-
-    pub(super) use_item_syntax: Option<ast::Use>,
 
     /// The parent function of the cursor position if it exists.
     pub(super) function_def: Option<ast::Fn>,
     /// The parent impl of the cursor position if it exists.
     pub(super) impl_def: Option<ast::Impl>,
+    pub(super) name_ref_syntax: Option<ast::NameRef>,
+    pub(super) use_item_syntax: Option<ast::Use>,
 
     // potentially set if we are completing a lifetime
     pub(super) lifetime_syntax: Option<ast::Lifetime>,
@@ -89,14 +89,12 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) completion_location: Option<ImmediateLocation>,
     pub(super) prev_sibling: Option<ImmediatePrevSibling>,
     pub(super) attribute_under_caret: Option<ast::Attr>,
+    pub(super) previous_token: Option<SyntaxToken>,
 
     pub(super) path_context: Option<PathCompletionContext>,
-    /// FIXME: `ActiveParameter` is string-based, which is very very wrong
     pub(super) active_parameter: Option<ActiveParameter>,
     pub(super) locals: Vec<(String, Local)>,
 
-    pub(super) previous_token: Option<SyntaxToken>,
-    pub(super) in_loop_body: bool,
     pub(super) incomplete_let: bool,
 
     no_completion_required: bool,
@@ -143,28 +141,27 @@ impl<'a> CompletionContext<'a> {
             original_token,
             token,
             krate,
-            lifetime_allowed: false,
             expected_name: None,
             expected_type: None,
+            function_def: None,
+            impl_def: None,
             name_ref_syntax: None,
+            use_item_syntax: None,
             lifetime_syntax: None,
             lifetime_param_syntax: None,
-            function_def: None,
-            use_item_syntax: None,
-            impl_def: None,
-            active_parameter: ActiveParameter::at(db, position),
+            lifetime_allowed: false,
             is_label_ref: false,
-            is_param: false,
             is_pat_or_const: None,
-            path_context: None,
-            previous_token: None,
-            in_loop_body: false,
+            is_param: false,
             completion_location: None,
             prev_sibling: None,
-            no_completion_required: false,
-            incomplete_let: false,
             attribute_under_caret: None,
+            previous_token: None,
+            path_context: None,
+            active_parameter: ActiveParameter::at(db, position),
             locals,
+            incomplete_let: false,
+            no_completion_required: false,
         };
 
         let mut original_file = original_file.syntax().clone();
@@ -326,10 +323,6 @@ impl<'a> CompletionContext<'a> {
         self.path_context.as_ref().and_then(|it| it.path_qual.as_ref())
     }
 
-    pub(crate) fn can_be_stmt(&self) -> bool {
-        self.path_context.as_ref().map_or(false, |it| it.can_be_stmt)
-    }
-
     fn fill_impl_def(&mut self) {
         self.impl_def = self
             .sema
@@ -455,7 +448,6 @@ impl<'a> CompletionContext<'a> {
             let for_is_prev2 = for_is_prev2(syntax_element.clone());
             (fn_is_prev && !inside_impl_trait_block) || for_is_prev2
         };
-        self.in_loop_body = is_in_loop_body(syntax_element.clone());
 
         self.incomplete_let =
             syntax_element.ancestors().take(6).find_map(ast::LetStmt::cast).map_or(false, |it| {
@@ -563,10 +555,6 @@ impl<'a> CompletionContext<'a> {
         self.name_ref_syntax =
             find_node_at_offset(original_file, name_ref.syntax().text_range().start());
 
-        if matches!(self.completion_location, Some(ImmediateLocation::ItemList)) {
-            return;
-        }
-
         self.use_item_syntax =
             self.sema.token_ancestors_with_macros(self.token.clone()).find_map(ast::Use::cast);
 
@@ -590,14 +578,16 @@ impl<'a> CompletionContext<'a> {
                 is_path_type: false,
                 can_be_stmt: false,
                 is_expr: false,
+                in_loop_body: false,
             });
+            path_ctx.in_loop_body = is_in_loop_body(name_ref.syntax());
             let path = segment.parent_path();
 
             if let Some(p) = path.syntax().parent() {
                 path_ctx.call_kind = match_ast! {
                     match p {
                         ast::PathExpr(it) => it.syntax().parent().and_then(ast::CallExpr::cast).map(|_| CallKind::Expr),
-                        ast::MacroCall(_it) => Some(CallKind::Mac),
+                        ast::MacroCall(it) => it.excl_token().and(Some(CallKind::Mac)),
                         ast::TupleStructPat(_it) => Some(CallKind::Pat),
                         _ => None
                     }
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 6fb38f50d..18983aa01 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -158,7 +158,6 @@ pub fn completions(
     completions::record::complete_record(&mut acc, &ctx);
     completions::pattern::complete_pattern(&mut acc, &ctx);
     completions::postfix::complete_postfix(&mut acc, &ctx);
-    completions::macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
     completions::trait_impl::complete_trait_impl(&mut acc, &ctx);
     completions::mod_::complete_mod(&mut acc, &ctx);
     completions::flyimport::import_on_the_fly(&mut acc, &ctx);
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index 251d76fe9..ee87bf461 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -272,9 +272,8 @@ fn test_for_is_prev2() {
     check_pattern_is_applicable(r"for i i$0", for_is_prev2);
 }
 
-pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
-    element
-        .ancestors()
+pub(crate) fn is_in_loop_body(node: &SyntaxNode) -> bool {
+    node.ancestors()
         .take_while(|it| it.kind() != FN && it.kind() != CLOSURE_EXPR)
         .find_map(|it| {
             let loop_body = match_ast! {
@@ -285,7 +284,7 @@ pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
                     _ => None,
                 }
             };
-            loop_body.filter(|it| it.syntax().text_range().contains_range(element.text_range()))
+            loop_body.filter(|it| it.syntax().text_range().contains_range(node.text_range()))
         })
         .is_some()
 }