1 files changed, 294 insertions, 111 deletions

diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index 04f2c532b..26516046b 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -1,38 +1,197 @@
 //! Patterns telling us certain facts about current syntax element, they are used in completion context
 
+use hir::Semantics;
+use ide_db::RootDatabase;
 use syntax::{
     algo::non_trivia_sibling,
     ast::{self, LoopBodyOwner},
-    match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
-    SyntaxKind::{self, *},
-    SyntaxNode, SyntaxToken, T,
+    match_ast, AstNode, Direction, SyntaxElement,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken, TextSize, T,
 };
 
 #[cfg(test)]
 use crate::test_utils::{check_pattern_is_applicable, check_pattern_is_not_applicable};
 
-pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element)
-        .filter(|it| it.kind() == ASSOC_ITEM_LIST)
-        .and_then(|it| it.parent())
-        .filter(|it| it.kind() == TRAIT)
-        .is_some()
+/// Direct parent container of the cursor position
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ImmediatePrevSibling {
+    IfExpr,
+    TraitDefName,
+    ImplDefType,
 }
-#[test]
-fn test_has_trait_parent() {
-    check_pattern_is_applicable(r"trait A { f$0 }", has_trait_parent);
+
+/// Direct parent container of the cursor position
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ImmediateLocation {
+    Use,
+    Impl,
+    Trait,
+    RecordField,
+    RefExpr,
+    IdentPat,
+    BlockExpr,
+    ItemList,
+    // Fake file ast node
+    Attribute(ast::Attr),
+    // Fake file ast node
+    ModDeclaration(ast::Module),
+    // Original file ast node
+    /// The record expr of the field name we are completing
+    RecordExpr(ast::RecordExpr),
+    // Original file ast node
+    /// The record pat of the field name we are completing
+    RecordPat(ast::RecordPat),
 }
 
-pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element)
-        .filter(|it| it.kind() == ASSOC_ITEM_LIST)
-        .and_then(|it| it.parent())
-        .filter(|it| it.kind() == IMPL)
-        .is_some()
+pub(crate) fn determine_prev_sibling(name_like: &ast::NameLike) -> Option<ImmediatePrevSibling> {
+    let node = match name_like {
+        ast::NameLike::NameRef(name_ref) => maximize_name_ref(name_ref),
+        ast::NameLike::Name(n) => n.syntax().clone(),
+        ast::NameLike::Lifetime(lt) => lt.syntax().clone(),
+    };
+    let node = match node.parent().and_then(ast::MacroCall::cast) {
+        // When a path is being typed after the name of a trait/type of an impl it is being
+        // parsed as a macro, so when the trait/impl has a block following it an we are between the
+        // name and block the macro will attach the block to itself so maximizing fails to take
+        // that into account
+        // FIXME path expr and statement have a similar problem with attrs
+        Some(call)
+            if call.excl_token().is_none()
+                && call.token_tree().map_or(false, |t| t.l_curly_token().is_some())
+                && call.semicolon_token().is_none() =>
+        {
+            call.syntax().clone()
+        }
+        _ => node,
+    };
+    let prev_sibling = non_trivia_sibling(node.into(), Direction::Prev)?.into_node()?;
+    let res = match_ast! {
+        match prev_sibling {
+            ast::ExprStmt(it) => {
+                let node = it.expr().filter(|_| it.semicolon_token().is_none())?.syntax().clone();
+                match_ast! {
+                    match node {
+                        ast::IfExpr(_it) => ImmediatePrevSibling::IfExpr,
+                        _ => return None,
+                    }
+                }
+            },
+            ast::Trait(it) => if it.assoc_item_list().is_none() {
+                    ImmediatePrevSibling::TraitDefName
+                } else {
+                    return None
+            },
+            ast::Impl(it) => if it.assoc_item_list().is_none()
+                && (it.for_token().is_none() || it.self_ty().is_some()) {
+                    ImmediatePrevSibling::ImplDefType
+                } else {
+                    return None
+            },
+            _ => return None,
+        }
+    };
+    Some(res)
 }
-#[test]
-fn test_has_impl_parent() {
-    check_pattern_is_applicable(r"impl A { f$0 }", has_impl_parent);
+
+pub(crate) fn determine_location(
+    sema: &Semantics<RootDatabase>,
+    original_file: &SyntaxNode,
+    offset: TextSize,
+    name_like: &ast::NameLike,
+) -> Option<ImmediateLocation> {
+    let node = match name_like {
+        ast::NameLike::NameRef(name_ref) => {
+            if ast::RecordExprField::for_field_name(&name_ref).is_some() {
+                return sema
+                    .find_node_at_offset_with_macros(original_file, offset)
+                    .map(ImmediateLocation::RecordExpr);
+            }
+            if ast::RecordPatField::for_field_name_ref(&name_ref).is_some() {
+                return sema
+                    .find_node_at_offset_with_macros(original_file, offset)
+                    .map(ImmediateLocation::RecordPat);
+            }
+            maximize_name_ref(name_ref)
+        }
+        ast::NameLike::Name(name) => {
+            if ast::RecordPatField::for_field_name(&name).is_some() {
+                return sema
+                    .find_node_at_offset_with_macros(original_file, offset)
+                    .map(ImmediateLocation::RecordPat);
+            }
+            name.syntax().clone()
+        }
+        ast::NameLike::Lifetime(lt) => lt.syntax().clone(),
+    };
+
+    let parent = match node.parent() {
+        Some(parent) => match ast::MacroCall::cast(parent.clone()) {
+            // When a path is being typed in an (Assoc)ItemList the parser will always emit a macro_call.
+            // This is usually fine as the node expansion code above already accounts for that with
+            // the ancestors call, but there is one exception to this which is that when an attribute
+            // precedes it the code above will not walk the Path to the parent MacroCall as their ranges differ.
+            // FIXME path expr and statement have a similar problem
+            Some(call)
+                if call.excl_token().is_none()
+                    && call.token_tree().is_none()
+                    && call.semicolon_token().is_none() =>
+            {
+                call.syntax().parent()?
+            }
+            _ => parent,
+        },
+        // SourceFile
+        None => {
+            return match node.kind() {
+                MACRO_ITEMS | SOURCE_FILE => Some(ImmediateLocation::ItemList),
+                _ => None,
+            }
+        }
+    };
+
+    let res = match_ast! {
+        match parent {
+            ast::IdentPat(_it) => ImmediateLocation::IdentPat,
+            ast::Use(_it) => ImmediateLocation::Use,
+            ast::BlockExpr(_it) => ImmediateLocation::BlockExpr,
+            ast::SourceFile(_it) => ImmediateLocation::ItemList,
+            ast::ItemList(_it) => ImmediateLocation::ItemList,
+            ast::RefExpr(_it) => ImmediateLocation::RefExpr,
+            ast::RecordField(_it) => ImmediateLocation::RecordField,
+            ast::AssocItemList(it) => match it.syntax().parent().map(|it| it.kind()) {
+                Some(IMPL) => ImmediateLocation::Impl,
+                Some(TRAIT) => ImmediateLocation::Trait,
+                _ => return None,
+            },
+            ast::Module(it) => if it.item_list().is_none() {
+                    ImmediateLocation::ModDeclaration(it)
+                } else {
+                    return None
+            },
+            ast::Attr(it) => ImmediateLocation::Attribute(it),
+            _ => return None,
+        }
+    };
+    Some(res)
+}
+
+fn maximize_name_ref(name_ref: &ast::NameRef) -> SyntaxNode {
+    // Maximize a nameref to its enclosing path if its the last segment of said path
+    if let Some(segment) = name_ref.syntax().parent().and_then(ast::PathSegment::cast) {
+        let p = segment.parent_path();
+        if p.parent_path().is_none() {
+            if let Some(it) = p
+                .syntax()
+                .ancestors()
+                .take_while(|it| it.text_range() == p.syntax().text_range())
+                .last()
+            {
+                return it;
+            }
+        }
+    }
+    name_ref.syntax().clone()
 }
 
 pub(crate) fn inside_impl_trait_block(element: SyntaxElement) -> bool {
@@ -53,68 +212,6 @@ fn test_inside_impl_trait_block() {
     check_pattern_is_not_applicable(r"impl A { fn f$0 }", inside_impl_trait_block);
 }
 
-pub(crate) fn has_field_list_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element).filter(|it| it.kind() == RECORD_FIELD_LIST).is_some()
-}
-#[test]
-fn test_has_field_list_parent() {
-    check_pattern_is_applicable(r"struct Foo { f$0 }", has_field_list_parent);
-    check_pattern_is_applicable(r"struct Foo { f$0 pub f: i32}", has_field_list_parent);
-}
-
-pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
-}
-#[test]
-fn test_has_block_expr_parent() {
-    check_pattern_is_applicable(r"fn my_fn() { let a = 2; f$0 }", has_block_expr_parent);
-}
-
-pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
-    element.ancestors().any(|it| it.kind() == IDENT_PAT)
-}
-
-#[test]
-fn test_has_bind_pat_parent() {
-    check_pattern_is_applicable(r"fn my_fn(m$0) {}", has_bind_pat_parent);
-    check_pattern_is_applicable(r"fn my_fn() { let m$0 }", has_bind_pat_parent);
-}
-
-pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element)
-        .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
-        .is_some()
-}
-#[test]
-fn test_has_ref_parent() {
-    check_pattern_is_applicable(r"fn my_fn(&m$0) {}", has_ref_parent);
-    check_pattern_is_applicable(r"fn my() { let &m$0 }", has_ref_parent);
-}
-
-pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
-    match not_same_range_ancestor(element) {
-        Some(it) => it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST,
-        None => true,
-    }
-}
-#[test]
-fn test_has_item_list_or_source_file_parent() {
-    check_pattern_is_applicable(r"i$0", has_item_list_or_source_file_parent);
-    check_pattern_is_applicable(r"mod foo { f$0 }", has_item_list_or_source_file_parent);
-}
-
-pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
-        && previous_sibling_or_ancestor_sibling(element)
-            .and_then(|it| it.into_token())
-            .filter(|it| it.kind() == FAT_ARROW)
-            .is_some()
-}
-#[test]
-fn test_is_match_arm() {
-    check_pattern_is_applicable(r"fn my_fn() { match () { () => m$0 } }", is_match_arm);
-}
-
 pub(crate) fn previous_token(element: SyntaxElement) -> Option<SyntaxToken> {
     element.into_token().and_then(|it| previous_non_trivia_token(it))
 }
@@ -134,14 +231,6 @@ fn test_for_is_prev2() {
     check_pattern_is_applicable(r"for i i$0", for_is_prev2);
 }
 
-pub(crate) fn has_prev_sibling(element: SyntaxElement, kind: SyntaxKind) -> bool {
-    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == kind).is_some()
-}
-#[test]
-fn test_has_impl_as_prev_sibling() {
-    check_pattern_is_applicable(r"impl A w$0 {}", |it| has_prev_sibling(it, IMPL));
-}
-
 pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
     element
         .ancestors()
@@ -160,14 +249,6 @@ pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
         .is_some()
 }
 
-fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
-    element
-        .ancestors()
-        .take_while(|it| it.text_range() == element.text_range())
-        .last()
-        .and_then(|it| it.parent())
-}
-
 fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
     let mut token = token.prev_token();
     while let Some(inner) = token.clone() {
@@ -180,17 +261,119 @@ fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
     None
 }
 
-fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<SyntaxElement> {
-    let token_sibling = non_trivia_sibling(element.clone(), Direction::Prev);
-    if let Some(sibling) = token_sibling {
-        Some(sibling)
-    } else {
-        // if not trying to find first ancestor which has such a sibling
-        let range = element.text_range();
-        let top_node = element.ancestors().take_while(|it| it.text_range() == range).last()?;
-        let prev_sibling_node = top_node.ancestors().find(|it| {
-            non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
-        })?;
-        non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
+#[cfg(test)]
+mod tests {
+    use syntax::algo::find_node_at_offset;
+
+    use crate::test_utils::position;
+
+    use super::*;
+
+    fn check_location(code: &str, loc: impl Into<Option<ImmediateLocation>>) {
+        let (db, pos) = position(code);
+
+        let sema = Semantics::new(&db);
+        let original_file = sema.parse(pos.file_id);
+
+        let name_like = find_node_at_offset(original_file.syntax(), pos.offset).unwrap();
+        assert_eq!(
+            determine_location(&sema, original_file.syntax(), pos.offset, &name_like),
+            loc.into()
+        );
+    }
+
+    fn check_prev_sibling(code: &str, sibling: impl Into<Option<ImmediatePrevSibling>>) {
+        check_pattern_is_applicable(code, |e| {
+            let name = &e.parent().and_then(ast::NameLike::cast).expect("Expected a namelike");
+            assert_eq!(determine_prev_sibling(name), sibling.into());
+            true
+        });
+    }
+
+    #[test]
+    fn test_trait_loc() {
+        check_location(r"trait A { f$0 }", ImmediateLocation::Trait);
+        check_location(r"trait A { #[attr] f$0 }", ImmediateLocation::Trait);
+        check_location(r"trait A { f$0 fn f() {} }", ImmediateLocation::Trait);
+        check_location(r"trait A { fn f() {} f$0 }", ImmediateLocation::Trait);
+        check_location(r"trait A$0 {}", None);
+        check_location(r"trait A { fn f$0 }", None);
+    }
+
+    #[test]
+    fn test_impl_loc() {
+        check_location(r"impl A { f$0 }", ImmediateLocation::Impl);
+        check_location(r"impl A { #[attr] f$0 }", ImmediateLocation::Impl);
+        check_location(r"impl A { f$0 fn f() {} }", ImmediateLocation::Impl);
+        check_location(r"impl A { fn f() {} f$0 }", ImmediateLocation::Impl);
+        check_location(r"impl A$0 {}", None);
+        check_location(r"impl A { fn f$0 }", None);
+    }
+
+    #[test]
+    fn test_use_loc() {
+        check_location(r"use f$0", ImmediateLocation::Use);
+        check_location(r"use f$0;", ImmediateLocation::Use);
+        check_location(r"use f::{f$0}", None);
+        check_location(r"use {f$0}", None);
+    }
+
+    #[test]
+    fn test_record_field_loc() {
+        check_location(r"struct Foo { f$0 }", ImmediateLocation::RecordField);
+        check_location(r"struct Foo { f$0 pub f: i32}", ImmediateLocation::RecordField);
+        check_location(r"struct Foo { pub f: i32, f$0 }", ImmediateLocation::RecordField);
+    }
+
+    #[test]
+    fn test_block_expr_loc() {
+        check_location(r"fn my_fn() { let a = 2; f$0 }", ImmediateLocation::BlockExpr);
+        check_location(r"fn my_fn() { f$0 f }", ImmediateLocation::BlockExpr);
+    }
+
+    #[test]
+    fn test_ident_pat_loc() {
+        check_location(r"fn my_fn(m$0) {}", ImmediateLocation::IdentPat);
+        check_location(r"fn my_fn() { let m$0 }", ImmediateLocation::IdentPat);
+        check_location(r"fn my_fn(&m$0) {}", ImmediateLocation::IdentPat);
+        check_location(r"fn my_fn() { let &m$0 }", ImmediateLocation::IdentPat);
+    }
+
+    #[test]
+    fn test_ref_expr_loc() {
+        check_location(r"fn my_fn() { let x = &m$0 foo; }", ImmediateLocation::RefExpr);
+    }
+
+    #[test]
+    fn test_item_list_loc() {
+        check_location(r"i$0", ImmediateLocation::ItemList);
+        check_location(r"#[attr] i$0", ImmediateLocation::ItemList);
+        check_location(r"fn f() {} i$0", ImmediateLocation::ItemList);
+        check_location(r"mod foo { f$0 }", ImmediateLocation::ItemList);
+        check_location(r"mod foo { #[attr] f$0 }", ImmediateLocation::ItemList);
+        check_location(r"mod foo { fn f() {} f$0 }", ImmediateLocation::ItemList);
+        check_location(r"mod foo$0 {}", None);
+    }
+
+    #[test]
+    fn test_impl_prev_sibling() {
+        check_prev_sibling(r"impl A w$0 ", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A w$0 {}", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A for A w$0 ", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A for A w$0 {}", ImmediatePrevSibling::ImplDefType);
+        check_prev_sibling(r"impl A for w$0 {}", None);
+        check_prev_sibling(r"impl A for w$0", None);
+    }
+
+    #[test]
+    fn test_trait_prev_sibling() {
+        check_prev_sibling(r"trait A w$0 ", ImmediatePrevSibling::TraitDefName);
+        check_prev_sibling(r"trait A w$0 {}", ImmediatePrevSibling::TraitDefName);
+    }
+
+    #[test]
+    fn test_if_expr_prev_sibling() {
+        check_prev_sibling(r"fn foo() { if true {} w$0", ImmediatePrevSibling::IfExpr);
+        check_prev_sibling(r"fn foo() { if true {}; w$0", None);
     }
 }