Merge #315

315: Split completion into manageable components r=matklad a=matklad

The main idea here is to do completion in two phases:

* first, we figure out surrounding context
* then, we run a series of completers on the given context. 

Co-authored-by: Aleksey Kladov <[email protected]>

9 files changed, 878 insertions, 771 deletions

diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs
index a11e98ac0..2d61a3aef 100644
--- a/crates/ra_analysis/src/completion.rs
+++ b/crates/ra_analysis/src/completion.rs
@@ -1,112 +1,50 @@
 mod completion_item;
-mod reference_completion;
+mod completion_context;
+
+mod complete_fn_param;
+mod complete_keyword;
+mod complete_snippet;
+mod complete_path;
+mod complete_scope;
 
-use ra_editor::find_node_at_offset;
-use ra_text_edit::AtomTextEdit;
-use ra_syntax::{
-    algo::visit::{visitor_ctx, VisitorCtx},
-    ast,
-    AstNode,
-    SyntaxNodeRef,
-};
 use ra_db::SyntaxDatabase;
-use rustc_hash::{FxHashMap};
-use hir::source_binder;
 
 use crate::{
     db,
     Cancelable, FilePosition,
-    completion::completion_item::{Completions, CompletionKind},
+    completion::{
+        completion_item::{Completions, CompletionKind},
+        completion_context::CompletionContext,
+    },
 };
 
 pub use crate::completion::completion_item::{CompletionItem, InsertText};
 
+/// Main entry point for copmletion. We run comletion as a two-phase process.
+///
+/// First, we look at the position and collect a so-called `CompletionContext.
+/// This is a somewhat messy process, because, during completion, syntax tree is
+/// incomplete and can look readlly weired.
+///
+/// Once the context is collected, we run a series of completion routines whihc
+/// look at the context and produce completion items.
 pub(crate) fn completions(
     db: &db::RootDatabase,
     position: FilePosition,
 ) -> Cancelable<Option<Completions>> {
     let original_file = db.source_file(position.file_id);
-    // Insert a fake ident to get a valid parse tree
-    let file = {
-        let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
-        original_file.reparse(&edit)
-    };
-
-    let module = ctry!(source_binder::module_from_position(db, position)?);
+    let ctx = ctry!(CompletionContext::new(db, &original_file, position)?);
 
     let mut acc = Completions::default();
-    let mut has_completions = false;
-    // First, let's try to complete a reference to some declaration.
-    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
-        has_completions = true;
-        reference_completion::completions(&mut acc, db, &module, &file, name_ref)?;
-        // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
-        if is_node::<ast::Param>(name_ref.syntax()) {
-            param_completions(&mut acc, name_ref.syntax());
-        }
-    }
 
-    // Otherwise, if this is a declaration, use heuristics to suggest a name.
-    if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) {
-        if is_node::<ast::Param>(name.syntax()) {
-            has_completions = true;
-            param_completions(&mut acc, name.syntax());
-        }
-    }
-    if !has_completions {
-        return Ok(None);
-    }
-    Ok(Some(acc))
-}
-
-/// Complete repeated parametes, both name and type. For example, if all
-/// functions in a file have a `spam: &mut Spam` parameter, a completion with
-/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
-/// suggested.
-fn param_completions(acc: &mut Completions, ctx: SyntaxNodeRef) {
-    let mut params = FxHashMap::default();
-    for node in ctx.ancestors() {
-        let _ = visitor_ctx(&mut params)
-            .visit::<ast::SourceFile, _>(process)
-            .visit::<ast::ItemList, _>(process)
-            .accept(node);
-    }
-    params
-        .into_iter()
-        .filter_map(|(label, (count, param))| {
-            let lookup = param.pat()?.syntax().text().to_string();
-            if count < 2 {
-                None
-            } else {
-                Some((label, lookup))
-            }
-        })
-        .for_each(|(label, lookup)| {
-            CompletionItem::new(label)
-                .lookup_by(lookup)
-                .kind(CompletionKind::Magic)
-                .add_to(acc)
-        });
-
-    fn process<'a, N: ast::FnDefOwner<'a>>(
-        node: N,
-        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
-    ) {
-        node.functions()
-            .filter_map(|it| it.param_list())
-            .flat_map(|it| it.params())
-            .for_each(|param| {
-                let text = param.syntax().text().to_string();
-                params.entry(text).or_insert((0, param)).0 += 1;
-            })
-    }
-}
+    complete_fn_param::complete_fn_param(&mut acc, &ctx);
+    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
+    complete_snippet::complete_expr_snippet(&mut acc, &ctx);
+    complete_snippet::complete_item_snippet(&mut acc, &ctx);
+    complete_path::complete_path(&mut acc, &ctx)?;
+    complete_scope::complete_scope(&mut acc, &ctx)?;
 
-fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
-    match node.ancestors().filter_map(N::cast).next() {
-        None => false,
-        Some(n) => n.syntax().range() == node.range(),
-    }
+    Ok(Some(acc))
 }
 
 #[cfg(test)]
@@ -120,51 +58,3 @@ fn check_completion(code: &str, expected_completions: &str, kind: CompletionKind
     let completions = completions(&analysis.imp.db, position).unwrap().unwrap();
     completions.assert_match(expected_completions, kind);
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn check_magic_completion(code: &str, expected_completions: &str) {
-        check_completion(code, expected_completions, CompletionKind::Magic);
-    }
-
-    #[test]
-    fn test_param_completion_last_param() {
-        check_magic_completion(
-            r"
-            fn foo(file_id: FileId) {}
-            fn bar(file_id: FileId) {}
-            fn baz(file<|>) {}
-            ",
-            r#"file_id "file_id: FileId""#,
-        );
-    }
-
-    #[test]
-    fn test_param_completion_nth_param() {
-        check_magic_completion(
-            r"
-            fn foo(file_id: FileId) {}
-            fn bar(file_id: FileId) {}
-            fn baz(file<|>, x: i32) {}
-            ",
-            r#"file_id "file_id: FileId""#,
-        );
-    }
-
-    #[test]
-    fn test_param_completion_trait_param() {
-        check_magic_completion(
-            r"
-            pub(crate) trait SourceRoot {
-                pub fn contains(&self, file_id: FileId) -> bool;
-                pub fn module_map(&self) -> &ModuleMap;
-                pub fn lines(&self, file_id: FileId) -> &LineIndex;
-                pub fn syntax(&self, file<|>)
-            }
-            ",
-            r#"file_id "file_id: FileId""#,
-        );
-    }
-}
diff --git a/crates/ra_analysis/src/completion/complete_fn_param.rs b/crates/ra_analysis/src/completion/complete_fn_param.rs
new file mode 100644
index 000000000..6a6213e67
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_fn_param.rs
@@ -0,0 +1,103 @@
+use ra_syntax::{
+    algo::visit::{visitor_ctx, VisitorCtx},
+    ast,
+    AstNode,
+};
+use rustc_hash::FxHashMap;
+
+use crate::completion::{CompletionContext, Completions, CompletionKind, CompletionItem};
+
+/// Complete repeated parametes, both name and type. For example, if all
+/// functions in a file have a `spam: &mut Spam` parameter, a completion with
+/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
+/// suggested.
+pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_param {
+        return;
+    }
+
+    let mut params = FxHashMap::default();
+    for node in ctx.leaf.ancestors() {
+        let _ = visitor_ctx(&mut params)
+            .visit::<ast::SourceFile, _>(process)
+            .visit::<ast::ItemList, _>(process)
+            .accept(node);
+    }
+    params
+        .into_iter()
+        .filter_map(|(label, (count, param))| {
+            let lookup = param.pat()?.syntax().text().to_string();
+            if count < 2 {
+                None
+            } else {
+                Some((label, lookup))
+            }
+        })
+        .for_each(|(label, lookup)| {
+            CompletionItem::new(label)
+                .lookup_by(lookup)
+                .kind(CompletionKind::Magic)
+                .add_to(acc)
+        });
+
+    fn process<'a, N: ast::FnDefOwner<'a>>(
+        node: N,
+        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
+    ) {
+        node.functions()
+            .filter_map(|it| it.param_list())
+            .flat_map(|it| it.params())
+            .for_each(|param| {
+                let text = param.syntax().text().to_string();
+                params.entry(text).or_insert((0, param)).0 += 1;
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::*;
+
+    fn check_magic_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Magic);
+    }
+
+    #[test]
+    fn test_param_completion_last_param() {
+        check_magic_completion(
+            r"
+            fn foo(file_id: FileId) {}
+            fn bar(file_id: FileId) {}
+            fn baz(file<|>) {}
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+
+    #[test]
+    fn test_param_completion_nth_param() {
+        check_magic_completion(
+            r"
+            fn foo(file_id: FileId) {}
+            fn bar(file_id: FileId) {}
+            fn baz(file<|>, x: i32) {}
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+
+    #[test]
+    fn test_param_completion_trait_param() {
+        check_magic_completion(
+            r"
+            pub(crate) trait SourceRoot {
+                pub fn contains(&self, file_id: FileId) -> bool;
+                pub fn module_map(&self) -> &ModuleMap;
+                pub fn lines(&self, file_id: FileId) -> &LineIndex;
+                pub fn syntax(&self, file<|>)
+            }
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_keyword.rs b/crates/ra_analysis/src/completion/complete_keyword.rs
new file mode 100644
index 000000000..dead15bb6
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_keyword.rs
@@ -0,0 +1,204 @@
+use ra_syntax::{
+    algo::visit::{visitor, Visitor},
+    AstNode,
+    ast::{self, LoopBodyOwner},
+    SyntaxKind::*, SyntaxNodeRef,
+};
+
+use crate::completion::{CompletionContext, CompletionItem, Completions, CompletionKind::*};
+
+pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_trivial_path {
+        return;
+    }
+    let fn_def = match ctx.enclosing_fn {
+        Some(it) => it,
+        None => return,
+    };
+    acc.add(keyword("if", "if $0 {}"));
+    acc.add(keyword("match", "match $0 {}"));
+    acc.add(keyword("while", "while $0 {}"));
+    acc.add(keyword("loop", "loop {$0}"));
+
+    if ctx.after_if {
+        acc.add(keyword("else", "else {$0}"));
+        acc.add(keyword("else if", "else if $0 {}"));
+    }
+    if is_in_loop_body(ctx.leaf) {
+        acc.add(keyword("continue", "continue"));
+        acc.add(keyword("break", "break"));
+    }
+    acc.add_all(complete_return(fn_def, ctx.is_stmt));
+}
+
+fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
+    for node in leaf.ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = visitor()
+            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
+            .accept(node);
+        if let Some(Some(body)) = loop_body {
+            if leaf.range().is_subrange(&body.syntax().range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn complete_return(fn_def: ast::FnDef, is_stmt: bool) -> Option<CompletionItem> {
+    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
+        (true, true) => "return $0;",
+        (true, false) => "return;",
+        (false, true) => "return $0",
+        (false, false) => "return",
+    };
+    Some(keyword("return", snip))
+}
+
+fn keyword(kw: &str, snippet: &str) -> CompletionItem {
+    CompletionItem::new(kw)
+        .kind(Keyword)
+        .snippet(snippet)
+        .build()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_keyword_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Keyword);
+    }
+
+    #[test]
+    fn test_completion_kewords() {
+        check_keyword_completion(
+            r"
+            fn quux() {
+                <|>
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return"
+            "#,
+        );
+    }
+
+    #[test]
+    fn test_completion_else() {
+        check_keyword_completion(
+            r"
+            fn quux() {
+                if true {
+                    ()
+                } <|>
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            else "else {$0}"
+            else if "else if $0 {}"
+            return "return"
+            "#,
+        );
+    }
+
+    #[test]
+    fn test_completion_return_value() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                <|>
+                92
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0;"
+            "#,
+        );
+        check_keyword_completion(
+            r"
+            fn quux() {
+                <|>
+                92
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return;"
+            "#,
+        );
+    }
+
+    #[test]
+    fn test_completion_return_no_stmt() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                match () {
+                    () => <|>
+                }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0"
+            "#,
+        );
+    }
+
+    #[test]
+    fn test_continue_break_completion() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                loop { <|> }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            continue "continue"
+            break "break"
+            return "return $0"
+            "#,
+        );
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                loop { || { <|> } }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0"
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_path.rs b/crates/ra_analysis/src/completion/complete_path.rs
new file mode 100644
index 000000000..5fc24af72
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_path.rs
@@ -0,0 +1,95 @@
+use crate::{
+    Cancelable,
+    completion::{CompletionItem, Completions, CompletionKind::*, CompletionContext},
+};
+
+pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+    let (path, module) = match (&ctx.path_prefix, &ctx.module) {
+        (Some(path), Some(module)) => (path.clone(), module),
+        _ => return Ok(()),
+    };
+    let def_id = match module.resolve_path(ctx.db, path)? {
+        Some(it) => it,
+        None => return Ok(()),
+    };
+    let target_module = match def_id.resolve(ctx.db)? {
+        hir::Def::Module(it) => it,
+        _ => return Ok(()),
+    };
+    let module_scope = target_module.scope(ctx.db)?;
+    module_scope.entries().for_each(|(name, _res)| {
+        CompletionItem::new(name.to_string())
+            .kind(Reference)
+            .add_to(acc)
+    });
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+
+    fn check_reference_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Reference);
+    }
+
+    #[test]
+    fn completes_use_item_starting_with_self() {
+        check_reference_completion(
+            r"
+            use self::m::<|>;
+
+            mod m {
+                struct Bar;
+            }
+            ",
+            "Bar",
+        );
+    }
+
+    #[test]
+    fn completes_use_item_starting_with_crate() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            struct Spam;
+            //- /foo.rs
+            use crate::Sp<|>
+            ",
+            "Spam;foo",
+        );
+    }
+
+    #[test]
+    fn completes_nested_use_tree() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            struct Spam;
+            //- /foo.rs
+            use crate::{Sp<|>};
+            ",
+            "Spam;foo",
+        );
+    }
+
+    #[test]
+    fn completes_deeply_nested_use_tree() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            pub mod bar {
+                pub mod baz {
+                    pub struct Spam;
+                }
+            }
+            //- /foo.rs
+            use crate::{bar::{baz::Sp<|>}};
+            ",
+            "Spam",
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs
new file mode 100644
index 000000000..d07c0e46d
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_scope.rs
@@ -0,0 +1,171 @@
+use rustc_hash::FxHashSet;
+use ra_syntax::TextUnit;
+
+use crate::{
+    Cancelable,
+    completion::{CompletionItem, Completions, CompletionKind::*, CompletionContext},
+};
+
+pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+    if !ctx.is_trivial_path {
+        return Ok(());
+    }
+    if let Some(fn_def) = ctx.enclosing_fn {
+        let scopes = hir::FnScopes::new(fn_def);
+        complete_fn(acc, &scopes, ctx.offset);
+    }
+
+    if let Some(module) = &ctx.module {
+        let module_scope = module.scope(ctx.db)?;
+        module_scope
+            .entries()
+            .filter(|(_name, res)| {
+                // Don't expose this item
+                match res.import {
+                    None => true,
+                    Some(import) => {
+                        let range = import.range(ctx.db, module.source().file_id());
+                        !range.is_subrange(&ctx.leaf.range())
+                    }
+                }
+            })
+            .for_each(|(name, _res)| {
+                CompletionItem::new(name.to_string())
+                    .kind(Reference)
+                    .add_to(acc)
+            });
+    }
+
+    Ok(())
+}
+
+fn complete_fn(acc: &mut Completions, scopes: &hir::FnScopes, offset: TextUnit) {
+    let mut shadowed = FxHashSet::default();
+    scopes
+        .scope_chain_for_offset(offset)
+        .flat_map(|scope| scopes.entries(scope).iter())
+        .filter(|entry| shadowed.insert(entry.name()))
+        .for_each(|entry| {
+            CompletionItem::new(entry.name().to_string())
+                .kind(Reference)
+                .add_to(acc)
+        });
+    if scopes.self_param.is_some() {
+        CompletionItem::new("self").kind(Reference).add_to(acc);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+
+    fn check_reference_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Reference);
+    }
+
+    #[test]
+    fn completes_bindings_from_let() {
+        check_reference_completion(
+            r"
+            fn quux(x: i32) {
+                let y = 92;
+                1 + <|>;
+                let z = ();
+            }
+            ",
+            "y;x;quux",
+        );
+    }
+
+    #[test]
+    fn completes_bindings_from_if_let() {
+        check_reference_completion(
+            r"
+            fn quux() {
+                if let Some(x) = foo() {
+                    let y = 92;
+                };
+                if let Some(a) = bar() {
+                    let b = 62;
+                    1 + <|>
+                }
+            }
+            ",
+            "b;a;quux",
+        );
+    }
+
+    #[test]
+    fn completes_bindings_from_for() {
+        check_reference_completion(
+            r"
+            fn quux() {
+                for x in &[1, 2, 3] {
+                    <|>
+                }
+            }
+            ",
+            "x;quux",
+        );
+    }
+
+    #[test]
+    fn completes_module_items() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            enum Baz {}
+            fn quux() {
+                <|>
+            }
+            ",
+            "quux;Foo;Baz",
+        );
+    }
+
+    #[test]
+    fn completes_module_items_in_nested_modules() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            mod m {
+                struct Bar;
+                fn quux() { <|> }
+            }
+            ",
+            "quux;Bar",
+        );
+    }
+
+    #[test]
+    fn completes_return_type() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            fn x() -> <|>
+            ",
+            "Foo;x",
+        )
+    }
+
+    #[test]
+    fn dont_show_to_completions_for_shadowing() {
+        check_reference_completion(
+            r"
+            fn foo() -> {
+                let bar = 92;
+                {
+                    let bar = 62;
+                    <|>
+                }
+            }
+            ",
+            "bar;foo",
+        )
+    }
+
+    #[test]
+    fn completes_self_in_methods() {
+        check_reference_completion(r"impl S { fn foo(&self) { <|> } }", "self")
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_snippet.rs b/crates/ra_analysis/src/completion/complete_snippet.rs
new file mode 100644
index 000000000..ccd68832b
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_snippet.rs
@@ -0,0 +1,76 @@
+use crate::completion::{CompletionItem, Completions, CompletionKind::*, CompletionContext};
+
+pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+    if !(ctx.is_trivial_path && ctx.enclosing_fn.is_some()) {
+        return;
+    }
+    CompletionItem::new("pd")
+        .snippet("eprintln!(\"$0 = {:?}\", $0);")
+        .kind(Snippet)
+        .add_to(acc);
+    CompletionItem::new("ppd")
+        .snippet("eprintln!(\"$0 = {:#?}\", $0);")
+        .kind(Snippet)
+        .add_to(acc);
+}
+
+pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_new_item {
+        return;
+    }
+    CompletionItem::new("Test function")
+        .lookup_by("tfn")
+        .snippet(
+            "\
+#[test]
+fn ${1:feature}() {
+    $0
+}",
+        )
+        .kind(Snippet)
+        .add_to(acc);
+    CompletionItem::new("pub(crate)")
+        .snippet("pub(crate) $0")
+        .kind(Snippet)
+        .add_to(acc);
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_snippet_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Snippet);
+    }
+
+    #[test]
+    fn completes_snippets_in_expressions() {
+        check_snippet_completion(
+            r"fn foo(x: i32) { <|> }",
+            r##"
+            pd "eprintln!(\"$0 = {:?}\", $0);"
+            ppd "eprintln!(\"$0 = {:#?}\", $0);"
+            "##,
+        );
+    }
+
+    #[test]
+    fn completes_snippets_in_items() {
+        // check_snippet_completion(r"
+        //     <|>
+        //     ",
+        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
+        // );
+        check_snippet_completion(
+            r"
+            #[cfg(test)]
+            mod tests {
+                <|>
+            }
+            ",
+            r##"
+            tfn "Test function" "#[test]\nfn ${1:feature}() {\n    $0\n}"
+            pub(crate) "pub(crate) $0"
+            "##,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/completion_context.rs b/crates/ra_analysis/src/completion/completion_context.rs
new file mode 100644
index 000000000..064fbc6f7
--- /dev/null
+++ b/crates/ra_analysis/src/completion/completion_context.rs
@@ -0,0 +1,156 @@
+use ra_editor::find_node_at_offset;
+use ra_text_edit::AtomTextEdit;
+use ra_syntax::{
+    algo::find_leaf_at_offset,
+    ast,
+    AstNode,
+    SyntaxNodeRef,
+    SourceFileNode,
+    TextUnit,
+    SyntaxKind::*,
+};
+use hir::source_binder;
+
+use crate::{db, FilePosition, Cancelable};
+
+/// `CompletionContext` is created early during completion to figure out, where
+/// exactly is the cursor, syntax-wise.
+#[derive(Debug)]
+pub(super) struct CompletionContext<'a> {
+    pub(super) db: &'a db::RootDatabase,
+    pub(super) offset: TextUnit,
+    pub(super) leaf: SyntaxNodeRef<'a>,
+    pub(super) module: Option<hir::Module>,
+    pub(super) enclosing_fn: Option<ast::FnDef<'a>>,
+    pub(super) is_param: bool,
+    /// A single-indent path, like `foo`.
+    pub(super) is_trivial_path: bool,
+    /// If not a trivial, path, the prefix (qualifier).
+    pub(super) path_prefix: Option<hir::Path>,
+    pub(super) after_if: bool,
+    pub(super) is_stmt: bool,
+    /// Something is typed at the "top" level, in module or impl/trait.
+    pub(super) is_new_item: bool,
+}
+
+impl<'a> CompletionContext<'a> {
+    pub(super) fn new(
+        db: &'a db::RootDatabase,
+        original_file: &'a SourceFileNode,
+        position: FilePosition,
+    ) -> Cancelable<Option<CompletionContext<'a>>> {
+        let module = source_binder::module_from_position(db, position)?;
+        let leaf =
+            ctry!(find_leaf_at_offset(original_file.syntax(), position.offset).left_biased());
+        let mut ctx = CompletionContext {
+            db,
+            leaf,
+            offset: position.offset,
+            module,
+            enclosing_fn: None,
+            is_param: false,
+            is_trivial_path: false,
+            path_prefix: None,
+            after_if: false,
+            is_stmt: false,
+            is_new_item: false,
+        };
+        ctx.fill(original_file, position.offset);
+        Ok(Some(ctx))
+    }
+
+    fn fill(&mut self, original_file: &SourceFileNode, offset: TextUnit) {
+        // Insert a fake ident to get a valid parse tree. We will use this file
+        // to determine context, though the original_file will be used for
+        // actual completion.
+        let file = {
+            let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string());
+            original_file.reparse(&edit)
+        };
+
+        // First, let's try to complete a reference to some declaration.
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), offset) {
+            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
+            // See RFC#1685.
+            if is_node::<ast::Param>(name_ref.syntax()) {
+                self.is_param = true;
+                return;
+            }
+            self.classify_name_ref(&file, name_ref);
+        }
+
+        // Otherwise, see if this is a declaration. We can use heuristics to
+        // suggest declaration names, see `CompletionKind::Magic`.
+        if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), offset) {
+            if is_node::<ast::Param>(name.syntax()) {
+                self.is_param = true;
+                return;
+            }
+        }
+    }
+    fn classify_name_ref(&mut self, file: &SourceFileNode, name_ref: ast::NameRef) {
+        let name_range = name_ref.syntax().range();
+        let top_node = name_ref
+            .syntax()
+            .ancestors()
+            .take_while(|it| it.range() == name_range)
+            .last()
+            .unwrap();
+
+        match top_node.parent().map(|it| it.kind()) {
+            Some(SOURCE_FILE) | Some(ITEM_LIST) => {
+                self.is_new_item = true;
+                return;
+            }
+            _ => (),
+        }
+
+        let parent = match name_ref.syntax().parent() {
+            Some(it) => it,
+            None => return,
+        };
+        if let Some(segment) = ast::PathSegment::cast(parent) {
+            let path = segment.parent_path();
+            if let Some(mut path) = hir::Path::from_ast(path) {
+                if !path.is_ident() {
+                    path.segments.pop().unwrap();
+                    self.path_prefix = Some(path);
+                    return;
+                }
+            }
+            if path.qualifier().is_none() {
+                self.is_trivial_path = true;
+                self.enclosing_fn = self
+                    .leaf
+                    .ancestors()
+                    .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
+                    .find_map(ast::FnDef::cast);
+
+                self.is_stmt = match name_ref
+                    .syntax()
+                    .ancestors()
+                    .filter_map(ast::ExprStmt::cast)
+                    .next()
+                {
+                    None => false,
+                    Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
+                };
+
+                if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
+                    if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
+                        if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
+                            self.after_if = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
+    match node.ancestors().filter_map(N::cast).next() {
+        None => false,
+        Some(n) => n.syntax().range() == node.range(),
+    }
+}
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
deleted file mode 100644
index c2ac95453..000000000
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ /dev/null
@@ -1,633 +0,0 @@
-use rustc_hash::{FxHashSet};
-use ra_editor::find_node_at_offset;
-use ra_syntax::{
-    algo::visit::{visitor, Visitor},
-    SourceFileNode, AstNode,
-    ast::{self, LoopBodyOwner},
-    SyntaxKind::*,
-};
-use hir::{
-    self,
-    FnScopes, Def, Path
-};
-
-use crate::{
-    db::RootDatabase,
-    completion::{CompletionItem, Completions, CompletionKind::*},
-    Cancelable
-};
-
-pub(super) fn completions(
-    acc: &mut Completions,
-    db: &RootDatabase,
-    module: &hir::Module,
-    file: &SourceFileNode,
-    name_ref: ast::NameRef,
-) -> Cancelable<()> {
-    let kind = match classify_name_ref(name_ref) {
-        Some(it) => it,
-        None => return Ok(()),
-    };
-
-    match kind {
-        NameRefKind::LocalRef { enclosing_fn } => {
-            if let Some(fn_def) = enclosing_fn {
-                let scopes = FnScopes::new(fn_def);
-                complete_fn(name_ref, &scopes, acc);
-                complete_expr_keywords(&file, fn_def, name_ref, acc);
-                complete_expr_snippets(acc);
-            }
-
-            let module_scope = module.scope(db)?;
-            module_scope
-                .entries()
-                .filter(|(_name, res)| {
-                    // Don't expose this item
-                    match res.import {
-                        None => true,
-                        Some(import) => {
-                            let range = import.range(db, module.source().file_id());
-                            !range.is_subrange(&name_ref.syntax().range())
-                        }
-                    }
-                })
-                .for_each(|(name, _res)| {
-                    CompletionItem::new(name.to_string())
-                        .kind(Reference)
-                        .add_to(acc)
-                });
-        }
-        NameRefKind::Path(path) => complete_path(acc, db, module, path)?,
-        NameRefKind::BareIdentInMod => {
-            let name_range = name_ref.syntax().range();
-            let top_node = name_ref
-                .syntax()
-                .ancestors()
-                .take_while(|it| it.range() == name_range)
-                .last()
-                .unwrap();
-            match top_node.parent().map(|it| it.kind()) {
-                Some(SOURCE_FILE) | Some(ITEM_LIST) => complete_mod_item_snippets(acc),
-                _ => (),
-            }
-        }
-    }
-    Ok(())
-}
-
-enum NameRefKind<'a> {
-    /// NameRef is a part of single-segment path, for example, a refernece to a
-    /// local variable.
-    LocalRef {
-        enclosing_fn: Option<ast::FnDef<'a>>,
-    },
-    /// NameRef is the last segment in some path
-    Path(Path),
-    /// NameRef is bare identifier at the module's root.
-    /// Used for keyword completion
-    BareIdentInMod,
-}
-
-fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
-    let name_range = name_ref.syntax().range();
-    let top_node = name_ref
-        .syntax()
-        .ancestors()
-        .take_while(|it| it.range() == name_range)
-        .last()
-        .unwrap();
-    match top_node.parent().map(|it| it.kind()) {
-        Some(SOURCE_FILE) | Some(ITEM_LIST) => return Some(NameRefKind::BareIdentInMod),
-        _ => (),
-    }
-
-    let parent = name_ref.syntax().parent()?;
-    if let Some(segment) = ast::PathSegment::cast(parent) {
-        let path = segment.parent_path();
-        if let Some(path) = Path::from_ast(path) {
-            if !path.is_ident() {
-                return Some(NameRefKind::Path(path));
-            }
-        }
-        if path.qualifier().is_none() {
-            let enclosing_fn = name_ref
-                .syntax()
-                .ancestors()
-                .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
-                .find_map(ast::FnDef::cast);
-            return Some(NameRefKind::LocalRef { enclosing_fn });
-        }
-    }
-    None
-}
-
-fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Completions) {
-    let mut shadowed = FxHashSet::default();
-    scopes
-        .scope_chain(name_ref.syntax())
-        .flat_map(|scope| scopes.entries(scope).iter())
-        .filter(|entry| shadowed.insert(entry.name()))
-        .for_each(|entry| {
-            CompletionItem::new(entry.name().to_string())
-                .kind(Reference)
-                .add_to(acc)
-        });
-    if scopes.self_param.is_some() {
-        CompletionItem::new("self").kind(Reference).add_to(acc);
-    }
-}
-
-fn complete_path(
-    acc: &mut Completions,
-    db: &RootDatabase,
-    module: &hir::Module,
-    mut path: Path,
-) -> Cancelable<()> {
-    if path.segments.is_empty() {
-        return Ok(());
-    }
-    path.segments.pop();
-    let def_id = match module.resolve_path(db, path)? {
-        None => return Ok(()),
-        Some(it) => it,
-    };
-    let target_module = match def_id.resolve(db)? {
-        Def::Module(it) => it,
-        _ => return Ok(()),
-    };
-    let module_scope = target_module.scope(db)?;
-    module_scope.entries().for_each(|(name, _res)| {
-        CompletionItem::new(name.to_string())
-            .kind(Reference)
-            .add_to(acc)
-    });
-    Ok(())
-}
-
-fn complete_mod_item_snippets(acc: &mut Completions) {
-    CompletionItem::new("Test function")
-        .lookup_by("tfn")
-        .snippet(
-            "\
-#[test]
-fn ${1:feature}() {
-    $0
-}",
-        )
-        .kind(Snippet)
-        .add_to(acc);
-    CompletionItem::new("pub(crate)")
-        .snippet("pub(crate) $0")
-        .kind(Snippet)
-        .add_to(acc);
-}
-
-fn complete_expr_keywords(
-    file: &SourceFileNode,
-    fn_def: ast::FnDef,
-    name_ref: ast::NameRef,
-    acc: &mut Completions,
-) {
-    acc.add(keyword("if", "if $0 {}"));
-    acc.add(keyword("match", "match $0 {}"));
-    acc.add(keyword("while", "while $0 {}"));
-    acc.add(keyword("loop", "loop {$0}"));
-
-    if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
-        if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
-            if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
-                acc.add(keyword("else", "else {$0}"));
-                acc.add(keyword("else if", "else if $0 {}"));
-            }
-        }
-    }
-    if is_in_loop_body(name_ref) {
-        acc.add(keyword("continue", "continue"));
-        acc.add(keyword("break", "break"));
-    }
-    acc.add_all(complete_return(fn_def, name_ref));
-}
-
-fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
-    for node in name_ref.syntax().ancestors() {
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
-        }
-        let loop_body = visitor()
-            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
-            .accept(node);
-        if let Some(Some(body)) = loop_body {
-            if name_ref
-                .syntax()
-                .range()
-                .is_subrange(&body.syntax().range())
-            {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
-    // let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
-    //     .next()
-    //     .and_then(|it| it.syntax().parent())
-    //     .and_then(ast::Block::cast)
-    //     .is_some();
-
-    // if is_last_in_block {
-    //     return None;
-    // }
-
-    let is_stmt = match name_ref
-        .syntax()
-        .ancestors()
-        .filter_map(ast::ExprStmt::cast)
-        .next()
-    {
-        None => false,
-        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
-    };
-    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
-        (true, true) => "return $0;",
-        (true, false) => "return;",
-        (false, true) => "return $0",
-        (false, false) => "return",
-    };
-    Some(keyword("return", snip))
-}
-
-fn keyword(kw: &str, snippet: &str) -> CompletionItem {
-    CompletionItem::new(kw)
-        .kind(Keyword)
-        .snippet(snippet)
-        .build()
-}
-
-fn complete_expr_snippets(acc: &mut Completions) {
-    CompletionItem::new("pd")
-        .snippet("eprintln!(\"$0 = {:?}\", $0);")
-        .kind(Snippet)
-        .add_to(acc);
-    CompletionItem::new("ppd")
-        .snippet("eprintln!(\"$0 = {:#?}\", $0);")
-        .kind(Snippet)
-        .add_to(acc);
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::completion::{CompletionKind, check_completion};
-
-    fn check_reference_completion(code: &str, expected_completions: &str) {
-        check_completion(code, expected_completions, CompletionKind::Reference);
-    }
-
-    fn check_keyword_completion(code: &str, expected_completions: &str) {
-        check_completion(code, expected_completions, CompletionKind::Keyword);
-    }
-
-    fn check_snippet_completion(code: &str, expected_completions: &str) {
-        check_completion(code, expected_completions, CompletionKind::Snippet);
-    }
-
-    #[test]
-    fn test_completion_let_scope() {
-        check_reference_completion(
-            r"
-            fn quux(x: i32) {
-                let y = 92;
-                1 + <|>;
-                let z = ();
-            }
-            ",
-            "y;x;quux",
-        );
-    }
-
-    #[test]
-    fn test_completion_if_let_scope() {
-        check_reference_completion(
-            r"
-            fn quux() {
-                if let Some(x) = foo() {
-                    let y = 92;
-                };
-                if let Some(a) = bar() {
-                    let b = 62;
-                    1 + <|>
-                }
-            }
-            ",
-            "b;a;quux",
-        );
-    }
-
-    #[test]
-    fn test_completion_for_scope() {
-        check_reference_completion(
-            r"
-            fn quux() {
-                for x in &[1, 2, 3] {
-                    <|>
-                }
-            }
-            ",
-            "x;quux",
-        );
-    }
-
-    #[test]
-    fn test_completion_mod_scope() {
-        check_reference_completion(
-            r"
-            struct Foo;
-            enum Baz {}
-            fn quux() {
-                <|>
-            }
-            ",
-            "quux;Foo;Baz",
-        );
-    }
-
-    #[test]
-    fn test_completion_mod_scope_no_self_use() {
-        check_reference_completion(
-            r"
-            use foo<|>;
-            ",
-            "",
-        );
-    }
-
-    #[test]
-    fn test_completion_self_path() {
-        check_reference_completion(
-            r"
-            use self::m::<|>;
-
-            mod m {
-                struct Bar;
-            }
-            ",
-            "Bar",
-        );
-    }
-
-    #[test]
-    fn test_completion_mod_scope_nested() {
-        check_reference_completion(
-            r"
-            struct Foo;
-            mod m {
-                struct Bar;
-                fn quux() { <|> }
-            }
-            ",
-            "quux;Bar",
-        );
-    }
-
-    #[test]
-    fn test_complete_type() {
-        check_reference_completion(
-            r"
-            struct Foo;
-            fn x() -> <|>
-            ",
-            "Foo;x",
-        )
-    }
-
-    #[test]
-    fn test_complete_shadowing() {
-        check_reference_completion(
-            r"
-            fn foo() -> {
-                let bar = 92;
-                {
-                    let bar = 62;
-                    <|>
-                }
-            }
-            ",
-            "bar;foo",
-        )
-    }
-
-    #[test]
-    fn test_complete_self() {
-        check_reference_completion(r"impl S { fn foo(&self) { <|> } }", "self")
-    }
-
-    #[test]
-    fn test_complete_crate_path() {
-        check_reference_completion(
-            "
-            //- /lib.rs
-            mod foo;
-            struct Spam;
-            //- /foo.rs
-            use crate::Sp<|>
-            ",
-            "Spam;foo",
-        );
-    }
-
-    #[test]
-    fn test_complete_crate_path_with_braces() {
-        check_reference_completion(
-            "
-            //- /lib.rs
-            mod foo;
-            struct Spam;
-            //- /foo.rs
-            use crate::{Sp<|>};
-            ",
-            "Spam;foo",
-        );
-    }
-
-    #[test]
-    fn test_complete_crate_path_in_nested_tree() {
-        check_reference_completion(
-            "
-            //- /lib.rs
-            mod foo;
-            pub mod bar {
-                pub mod baz {
-                    pub struct Spam;
-                }
-            }
-            //- /foo.rs
-            use crate::{bar::{baz::Sp<|>}};
-            ",
-            "Spam",
-        );
-    }
-
-    #[test]
-    fn test_completion_kewords() {
-        check_keyword_completion(
-            r"
-            fn quux() {
-                <|>
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return"
-            "#,
-        );
-    }
-
-    #[test]
-    fn test_completion_else() {
-        check_keyword_completion(
-            r"
-            fn quux() {
-                if true {
-                    ()
-                } <|>
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            else "else {$0}"
-            else if "else if $0 {}"
-            return "return"
-            "#,
-        );
-    }
-
-    #[test]
-    fn test_completion_return_value() {
-        check_keyword_completion(
-            r"
-            fn quux() -> i32 {
-                <|>
-                92
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0;"
-            "#,
-        );
-        check_keyword_completion(
-            r"
-            fn quux() {
-                <|>
-                92
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return;"
-            "#,
-        );
-    }
-
-    #[test]
-    fn test_completion_return_no_stmt() {
-        check_keyword_completion(
-            r"
-            fn quux() -> i32 {
-                match () {
-                    () => <|>
-                }
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0"
-            "#,
-        );
-    }
-
-    #[test]
-    fn test_continue_break_completion() {
-        check_keyword_completion(
-            r"
-            fn quux() -> i32 {
-                loop { <|> }
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            continue "continue"
-            break "break"
-            return "return $0"
-            "#,
-        );
-        check_keyword_completion(
-            r"
-            fn quux() -> i32 {
-                loop { || { <|> } }
-            }
-            ",
-            r#"
-            if "if $0 {}"
-            match "match $0 {}"
-            while "while $0 {}"
-            loop "loop {$0}"
-            return "return $0"
-            "#,
-        );
-    }
-
-    #[test]
-    fn completes_snippets_in_expressions() {
-        check_snippet_completion(
-            r"fn foo(x: i32) { <|> }",
-            r##"
-            pd "eprintln!(\"$0 = {:?}\", $0);"
-            ppd "eprintln!(\"$0 = {:#?}\", $0);"
-            "##,
-        );
-    }
-
-    #[test]
-    fn completes_snippets_in_items() {
-        // check_snippet_completion(r"
-        //     <|>
-        //     ",
-        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
-        // );
-        check_snippet_completion(
-            r"
-            #[cfg(test)]
-            mod tests {
-                <|>
-            }
-            ",
-            r##"
-            tfn "Test function" "#[test]\nfn ${1:feature}() {\n    $0\n}"
-            pub(crate) "pub(crate) $0"
-            "##,
-        );
-    }
-
-}
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 863453291..9f1aa1ef2 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,7 +1,7 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use ra_syntax::{
-    AstNode, SmolStr, SyntaxNodeRef, TextRange,
+    AstNode, SmolStr, SyntaxNodeRef, TextUnit, TextRange,
     algo::generate,
     ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
 };
@@ -57,6 +57,48 @@ impl FnScopes {
             self.scopes[scope].parent
         })
     }
+    pub fn scope_chain_for_offset<'a>(
+        &'a self,
+        offset: TextUnit,
+    ) -> impl Iterator<Item = ScopeId> + 'a {
+        let scope = self
+            .scope_for
+            .iter()
+            // find containin scope
+            .min_by_key(|(ptr, _scope)| {
+                (
+                    !(ptr.range().start() <= offset && offset <= ptr.range().end()),
+                    ptr.range().len(),
+                )
+            })
+            .map(|(ptr, scope)| self.adjust(*ptr, *scope, offset));
+
+        generate(scope, move |&scope| self.scopes[scope].parent)
+    }
+    // XXX: during completion, cursor might be outside of any particular
+    // expression. Try to figure out the correct scope...
+    fn adjust(&self, ptr: LocalSyntaxPtr, original_scope: ScopeId, offset: TextUnit) -> ScopeId {
+        let r = ptr.range();
+        let child_scopes = self
+            .scope_for
+            .iter()
+            .map(|(ptr, scope)| (ptr.range(), scope))
+            .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
+
+        child_scopes
+            .max_by(|(r1, _), (r2, _)| {
+                if r2.is_subrange(&r1) {
+                    std::cmp::Ordering::Greater
+                } else if r1.is_subrange(&r2) {
+                    std::cmp::Ordering::Less
+                } else {
+                    r1.start().cmp(&r2.start())
+                }
+            })
+            .map(|(ptr, scope)| *scope)
+            .unwrap_or(original_scope)
+    }
+
     pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
         let mut shadowed = FxHashSet::default();
         let ret = self
@@ -144,6 +186,8 @@ impl ScopeEntry {
 }
 
 fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: ScopeId) {
+    // A hack for completion :(
+    scopes.set_scope(block.syntax(), scope);
     for stmt in block.statements() {
         match stmt {
             ast::Stmt::LetStmt(stmt) => {
@@ -165,6 +209,7 @@ fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: Sco
         }
     }
     if let Some(expr) = block.expr() {
+        eprintln!("{:?}", expr);
         scopes.set_scope(expr.syntax(), scope);
         compute_expr_scopes(expr, scopes, scope);
     }