1 files changed, 106 insertions, 50 deletions

diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 4c3929a26..f0da98739 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -43,6 +43,8 @@ pub(crate) struct PathCompletionContext {
     pub(super) is_trivial_path: bool,
     /// If not a trivial path, the prefix (qualifier).
     pub(super) qualifier: Option<ast::Path>,
+    /// Whether the qualifier comes from a use tree parent or not
+    pub(super) use_tree_parent: bool,
     pub(super) kind: Option<PathKind>,
     /// Whether the path segment has type args or not.
     pub(super) has_type_args: bool,
@@ -79,7 +81,6 @@ pub(crate) struct CompletionContext<'a> {
     /// 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>,
@@ -151,7 +152,6 @@ impl<'a> CompletionContext<'a> {
             function_def: None,
             impl_def: None,
             name_ref_syntax: None,
-            use_item_syntax: None,
             lifetime_syntax: None,
             lifetime_param_syntax: None,
             lifetime_allowed: false,
@@ -242,32 +242,27 @@ impl<'a> CompletionContext<'a> {
     }
 
     pub(crate) fn expects_assoc_item(&self) -> bool {
-        matches!(
-            self.completion_location,
-            Some(ImmediateLocation::Trait) | Some(ImmediateLocation::Impl)
-        )
+        matches!(self.completion_location, Some(ImmediateLocation::Trait | ImmediateLocation::Impl))
     }
 
     pub(crate) fn has_dot_receiver(&self) -> bool {
         matches!(
             &self.completion_location,
-            Some(ImmediateLocation::FieldAccess { receiver, .. }) | Some(ImmediateLocation::MethodCall { receiver,.. })
+            Some(ImmediateLocation::FieldAccess { receiver, .. } | ImmediateLocation::MethodCall { receiver,.. })
                 if receiver.is_some()
         )
     }
 
     pub(crate) fn dot_receiver(&self) -> Option<&ast::Expr> {
         match &self.completion_location {
-            Some(ImmediateLocation::MethodCall { receiver, .. })
-            | Some(ImmediateLocation::FieldAccess { receiver, .. }) => receiver.as_ref(),
+            Some(
+                ImmediateLocation::MethodCall { receiver, .. }
+                | ImmediateLocation::FieldAccess { receiver, .. },
+            ) => receiver.as_ref(),
             _ => None,
         }
     }
 
-    pub(crate) fn expects_use_tree(&self) -> bool {
-        matches!(self.completion_location, Some(ImmediateLocation::Use))
-    }
-
     pub(crate) fn expects_non_trait_assoc_item(&self) -> bool {
         matches!(self.completion_location, Some(ImmediateLocation::Impl))
     }
@@ -276,6 +271,10 @@ impl<'a> CompletionContext<'a> {
         matches!(self.completion_location, Some(ImmediateLocation::ItemList))
     }
 
+    pub(crate) fn expects_generic_arg(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::GenericArgList(_)))
+    }
+
     pub(crate) fn has_block_expr_parent(&self) -> bool {
         matches!(self.completion_location, Some(ImmediateLocation::BlockExpr))
     }
@@ -283,33 +282,59 @@ impl<'a> CompletionContext<'a> {
     pub(crate) fn expects_ident_pat_or_ref_expr(&self) -> bool {
         matches!(
             self.completion_location,
-            Some(ImmediateLocation::IdentPat) | Some(ImmediateLocation::RefExpr)
+            Some(ImmediateLocation::IdentPat | ImmediateLocation::RefExpr)
         )
     }
 
-    pub(crate) fn expect_record_field(&self) -> bool {
-        matches!(self.completion_location, Some(ImmediateLocation::RecordField))
+    pub(crate) fn expect_field(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::RecordField | ImmediateLocation::TupleField)
+        )
+    }
+
+    pub(crate) fn in_use_tree(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::Use | ImmediateLocation::UseTree)
+        )
     }
 
     pub(crate) fn has_impl_or_trait_prev_sibling(&self) -> bool {
         matches!(
             self.prev_sibling,
-            Some(ImmediatePrevSibling::ImplDefType) | Some(ImmediatePrevSibling::TraitDefName)
+            Some(ImmediatePrevSibling::ImplDefType | ImmediatePrevSibling::TraitDefName)
         )
     }
 
+    pub(crate) fn has_impl_prev_sibling(&self) -> bool {
+        matches!(self.prev_sibling, Some(ImmediatePrevSibling::ImplDefType))
+    }
+
+    pub(crate) fn has_visibility_prev_sibling(&self) -> bool {
+        matches!(self.prev_sibling, Some(ImmediatePrevSibling::Visibility))
+    }
+
     pub(crate) fn after_if(&self) -> bool {
         matches!(self.prev_sibling, Some(ImmediatePrevSibling::IfExpr))
     }
 
     pub(crate) fn is_path_disallowed(&self) -> bool {
-        matches!(
-            self.completion_location,
-            Some(ImmediateLocation::Attribute(_))
-                | Some(ImmediateLocation::ModDeclaration(_))
-                | Some(ImmediateLocation::RecordPat(_))
-                | Some(ImmediateLocation::RecordExpr(_))
-        ) || self.attribute_under_caret.is_some()
+        self.attribute_under_caret.is_some()
+            || self.previous_token_is(T![unsafe])
+            || matches!(
+                self.prev_sibling,
+                Some(ImmediatePrevSibling::Attribute | ImmediatePrevSibling::Visibility)
+            )
+            || matches!(
+                self.completion_location,
+                Some(
+                    ImmediateLocation::Attribute(_)
+                        | ImmediateLocation::ModDeclaration(_)
+                        | ImmediateLocation::RecordPat(_)
+                        | ImmediateLocation::RecordExpr(_)
+                )
+            )
     }
 
     pub(crate) fn expects_expression(&self) -> bool {
@@ -363,14 +388,19 @@ impl<'a> CompletionContext<'a> {
                         (ty, name)
                     },
                     ast::ArgList(_it) => {
-                        cov_mark::hit!(expected_type_fn_param_with_leading_char);
-                        cov_mark::hit!(expected_type_fn_param_without_leading_char);
+                        cov_mark::hit!(expected_type_fn_param);
                         ActiveParameter::at_token(
                             &self.sema,
                             self.token.clone(),
                         ).map(|ap| {
                             let name = ap.ident().map(NameOrNameRef::Name);
-                            (Some(ap.ty), name)
+                            let ty = if has_ref(&self.token) {
+                                cov_mark::hit!(expected_type_fn_param_ref);
+                                ap.ty.remove_ref()
+                            } else {
+                                Some(ap.ty)
+                            };
+                            (ty, name)
                         })
                         .unwrap_or((None, None))
                     },
@@ -564,9 +594,6 @@ impl<'a> CompletionContext<'a> {
         self.name_ref_syntax =
             find_node_at_offset(original_file, name_ref.syntax().text_range().start());
 
-        self.use_item_syntax =
-            self.sema.token_ancestors_with_macros(self.token.clone()).find_map(ast::Use::cast);
-
         self.function_def = self
             .sema
             .token_ancestors_with_macros(self.token.clone())
@@ -586,6 +613,7 @@ impl<'a> CompletionContext<'a> {
                 has_type_args: false,
                 can_be_stmt: false,
                 in_loop_body: false,
+                use_tree_parent: false,
                 kind: None,
             });
             path_ctx.in_loop_body = is_in_loop_body(name_ref.syntax());
@@ -613,7 +641,8 @@ impl<'a> CompletionContext<'a> {
             }
             path_ctx.has_type_args = segment.generic_arg_list().is_some();
 
-            if let Some(path) = path_or_use_tree_qualifier(&path) {
+            if let Some((path, use_tree_parent)) = path_or_use_tree_qualifier(&path) {
+                path_ctx.use_tree_parent = use_tree_parent;
                 path_ctx.qualifier = path
                     .segment()
                     .and_then(|it| {
@@ -667,13 +696,26 @@ fn is_node<N: AstNode>(node: &SyntaxNode) -> bool {
     }
 }
 
-fn path_or_use_tree_qualifier(path: &ast::Path) -> Option<ast::Path> {
+fn path_or_use_tree_qualifier(path: &ast::Path) -> Option<(ast::Path, bool)> {
     if let Some(qual) = path.qualifier() {
-        return Some(qual);
+        return Some((qual, false));
     }
     let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
     let use_tree = use_tree_list.syntax().parent().and_then(ast::UseTree::cast)?;
-    use_tree.path()
+    use_tree.path().zip(Some(true))
+}
+
+fn has_ref(token: &SyntaxToken) -> bool {
+    let mut token = token.clone();
+    for skip in [WHITESPACE, IDENT, T![mut]] {
+        if token.kind() == skip {
+            token = match token.prev_token() {
+                Some(it) => it,
+                None => return false,
+            }
+        }
+    }
+    token.kind() == T![&]
 }
 
 #[cfg(test)]
@@ -681,7 +723,7 @@ mod tests {
     use expect_test::{expect, Expect};
     use hir::HirDisplay;
 
-    use crate::test_utils::{position, TEST_CONFIG};
+    use crate::tests::{position, TEST_CONFIG};
 
     use super::CompletionContext;
 
@@ -748,14 +790,18 @@ fn foo() {
     }
 
     #[test]
-    fn expected_type_fn_param_without_leading_char() {
-        cov_mark::check!(expected_type_fn_param_without_leading_char);
+    fn expected_type_fn_param() {
+        cov_mark::check!(expected_type_fn_param);
         check_expected_type_and_name(
             r#"
-fn foo() {
-    bar($0);
-}
-
+fn foo() { bar($0); }
+fn bar(x: u32) {}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+        check_expected_type_and_name(
+            r#"
+fn foo() { bar(c$0); }
 fn bar(x: u32) {}
 "#,
             expect![[r#"ty: u32, name: x"#]],
@@ -763,18 +809,29 @@ fn bar(x: u32) {}
     }
 
     #[test]
-    fn expected_type_fn_param_with_leading_char() {
-        cov_mark::check!(expected_type_fn_param_with_leading_char);
+    fn expected_type_fn_param_ref() {
+        cov_mark::check!(expected_type_fn_param_ref);
         check_expected_type_and_name(
             r#"
-fn foo() {
-    bar(c$0);
-}
-
-fn bar(x: u32) {}
+fn foo() { bar(&$0); }
+fn bar(x: &u32) {}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+        check_expected_type_and_name(
+            r#"
+fn foo() { bar(&mut $0); }
+fn bar(x: &mut u32) {}
 "#,
             expect![[r#"ty: u32, name: x"#]],
         );
+        check_expected_type_and_name(
+            r#"
+fn foo() { bar(&c$0); }
+fn bar(x: &u32) {}
+        "#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
     }
 
     #[test]
@@ -921,13 +978,12 @@ fn foo() -> u32 {
         // FIXME: make this work with `|| $0`
         check_expected_type_and_name(
             r#"
+//- minicore: fn
 fn foo() {
     bar(|| a$0);
 }
 
 fn bar(f: impl FnOnce() -> u32) {}
-#[lang = "fn_once"]
-trait FnOnce { type Output; }
 "#,
             expect![[r#"ty: u32, name: ?"#]],
         );