diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion/mod.rs
similarity index 64%
rename from crates/ra_analysis/src/completion.rs
rename to crates/ra_analysis/src/completion/mod.rs
index 27566a8a14..7635330125 100644
--- a/crates/ra_analysis/src/completion.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -1,20 +1,17 @@
+mod reference_completion;
+
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    algo::visit::{visitor, visitor_ctx, Visitor, VisitorCtx},
-    ast::{self, AstChildren, LoopBodyOwner, ModuleItemOwner},
-    AstNode, AtomEdit, SourceFileNode,
-    SyntaxKind::*,
+    algo::visit::{visitor_ctx, VisitorCtx},
+    ast,
+    AstNode, AtomEdit,
     SyntaxNodeRef,
 };
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::{FxHashMap};
 
 use crate::{
     db::{self, SyntaxDatabase},
-    descriptors::function::FnScopes,
-    descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
-    descriptors::DescriptorDatabase,
-    input::FilesDatabase,
-    Cancelable, FilePosition, FileId,
+    Cancelable, FilePosition
 };
 
 #[derive(Debug)]
@@ -43,27 +40,11 @@ pub(crate) fn completions(
     // 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;
-        // completion from lexical scope
-        complete_name_ref(&file, name_ref, &mut res);
+        reference_completion::completions(&mut res, db, position.file_id, &file, name_ref)?;
         // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
         if is_node::<ast::Param>(name_ref.syntax()) {
             param_completions(name_ref.syntax(), &mut res);
         }
-        // snippet completions
-        {
-            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(&mut res),
-                _ => (),
-            }
-        }
-        complete_path(db, position.file_id, name_ref, &mut res)?;
     }
 
     // Otherwise, if this is a declaration, use heuristics to suggest a name.
@@ -77,117 +58,6 @@ pub(crate) fn completions(
     Ok(res)
 }
 
-fn complete_path(
-    db: &db::RootDatabase,
-    file_id: FileId,
-    name_ref: ast::NameRef,
-    acc: &mut Vec<CompletionItem>,
-) -> Cancelable<()> {
-    let source_root_id = db.file_source_root(file_id);
-    let module_tree = db.module_tree(source_root_id)?;
-    let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
-        None => return Ok(()),
-        Some(it) => it,
-    };
-    let target_module_id = match find_target_module(&module_tree, module_id, name_ref) {
-        None => return Ok(()),
-        Some(it) => it,
-    };
-    let module_scope = db.module_scope(source_root_id, target_module_id)?;
-    let completions = module_scope.entries().iter().map(|entry| CompletionItem {
-        label: entry.name().to_string(),
-        lookup: None,
-        snippet: None,
-    });
-    acc.extend(completions);
-    Ok(())
-}
-
-fn find_target_module(
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
-    name_ref: ast::NameRef,
-) -> Option<ModuleId> {
-    let mut crate_path = crate_path(name_ref)?;
-
-    crate_path.pop();
-    let mut target_module = module_id.root(&module_tree);
-    for name in crate_path {
-        target_module = target_module.child(module_tree, name.text().as_str())?;
-    }
-    Some(target_module)
-}
-
-fn crate_path(name_ref: ast::NameRef) -> Option<Vec<ast::NameRef>> {
-    let mut path = name_ref
-        .syntax()
-        .parent()
-        .and_then(ast::PathSegment::cast)?
-        .parent_path();
-    let mut res = Vec::new();
-    loop {
-        let segment = path.segment()?;
-        match segment.kind()? {
-            ast::PathSegmentKind::Name(name) => res.push(name),
-            ast::PathSegmentKind::CrateKw => break,
-            ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
-        }
-        path = path.qualifier()?;
-    }
-    res.reverse();
-    Some(res)
-}
-
-fn complete_module_items(
-    file: &SourceFileNode,
-    items: AstChildren<ast::ModuleItem>,
-    this_item: Option<ast::NameRef>,
-    acc: &mut Vec<CompletionItem>,
-) {
-    let scope = ModuleScope::new(items); // FIXME
-    acc.extend(
-        scope
-            .entries()
-            .iter()
-            .filter(|entry| {
-                let syntax = entry.ptr().resolve(file);
-                Some(syntax.borrowed()) != this_item.map(|it| it.syntax())
-            })
-            .map(|entry| CompletionItem {
-                label: entry.name().to_string(),
-                lookup: None,
-                snippet: None,
-            }),
-    );
-}
-
-fn complete_name_ref(file: &SourceFileNode, name_ref: ast::NameRef, acc: &mut Vec<CompletionItem>) {
-    if !is_node::<ast::Path>(name_ref.syntax()) {
-        return;
-    }
-    let mut visited_fn = false;
-    for node in name_ref.syntax().ancestors() {
-        if let Some(items) = visitor()
-            .visit::<ast::SourceFile, _>(|it| Some(it.items()))
-            .visit::<ast::Module, _>(|it| Some(it.item_list()?.items()))
-            .accept(node)
-        {
-            if let Some(items) = items {
-                complete_module_items(file, items, Some(name_ref), acc);
-            }
-            break;
-        } else if !visited_fn {
-            if let Some(fn_def) = ast::FnDef::cast(node) {
-                visited_fn = true;
-                complete_expr_keywords(&file, fn_def, name_ref, acc);
-                complete_expr_snippets(acc);
-                let scopes = FnScopes::new(fn_def);
-                complete_fn(name_ref, &scopes, acc);
-            }
-        }
-    }
-}
-
 fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) {
     let mut params = FxHashMap::default();
     for node in ctx.ancestors() {
@@ -235,140 +105,6 @@ fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
     }
 }
 
-fn complete_expr_keywords(
-    file: &SourceFileNode,
-    fn_def: ast::FnDef,
-    name_ref: ast::NameRef,
-    acc: &mut Vec<CompletionItem>,
-) {
-    acc.push(keyword("if", "if $0 {}"));
-    acc.push(keyword("match", "match $0 {}"));
-    acc.push(keyword("while", "while $0 {}"));
-    acc.push(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.push(keyword("else", "else {$0}"));
-                acc.push(keyword("else if", "else if $0 {}"));
-            }
-        }
-    }
-    if is_in_loop_body(name_ref) {
-        acc.push(keyword("continue", "continue"));
-        acc.push(keyword("break", "break"));
-    }
-    acc.extend(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, snip: &str) -> CompletionItem {
-    CompletionItem {
-        label: kw.to_string(),
-        lookup: None,
-        snippet: Some(snip.to_string()),
-    }
-}
-
-fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "pd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
-    });
-    acc.push(CompletionItem {
-        label: "ppd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
-    });
-}
-
-fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "tfn".to_string(),
-        lookup: None,
-        snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
-    });
-    acc.push(CompletionItem {
-        label: "pub(crate)".to_string(),
-        lookup: None,
-        snippet: Some("pub(crate) $0".to_string()),
-    })
-}
-
-fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
-    let mut shadowed = FxHashSet::default();
-    acc.extend(
-        scopes
-            .scope_chain(name_ref.syntax())
-            .flat_map(|scope| scopes.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .map(|entry| CompletionItem {
-                label: entry.name().to_string(),
-                lookup: None,
-                snippet: None,
-            }),
-    );
-    if scopes.self_param.is_some() {
-        acc.push(CompletionItem {
-            label: "self".to_string(),
-            lookup: None,
-            snippet: None,
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use test_utils::assert_eq_dbg;
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
new file mode 100644
index 0000000000..b081749689
--- /dev/null
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -0,0 +1,331 @@
+use rustc_hash::{FxHashSet};
+use ra_editor::find_node_at_offset;
+use ra_syntax::{
+    algo::visit::{visitor, Visitor},
+    SourceFileNode, AstNode,
+    ast::{self, AstChildren, ModuleItemOwner, LoopBodyOwner},
+    SyntaxKind::*,
+};
+
+use crate::{
+    db::RootDatabase,
+    input::FilesDatabase,
+    completion::CompletionItem,
+    descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
+    descriptors::function::FnScopes,
+    descriptors::DescriptorDatabase,
+    FileId, Cancelable
+};
+
+pub(super) fn completions(
+    acc: &mut Vec<CompletionItem>,
+    db: &RootDatabase,
+    file_id: FileId,
+    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 => {
+            if let Some(fn_def) = complete_local_name(acc, &file, name_ref) {
+                complete_expr_keywords(&file, fn_def, name_ref, acc);
+                complete_expr_snippets(acc);
+            }
+        }
+        NameRefKind::CratePath(path) => complete_path(acc, db, file_id, 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,
+    /// NameRef is the last segment in crate:: path
+    CratePath(Vec<ast::NameRef<'a>>),
+    /// 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 path.qualifier().is_none() {
+            return Some(NameRefKind::LocalRef);
+        }
+        if let Some(crate_path) = crate_path(path) {
+            return Some(NameRefKind::CratePath(crate_path));
+        }
+    }
+    None
+}
+
+fn crate_path(mut path: ast::Path) -> Option<Vec<ast::NameRef>> {
+    let mut res = Vec::new();
+    loop {
+        let segment = path.segment()?;
+        match segment.kind()? {
+            ast::PathSegmentKind::Name(name) => res.push(name),
+            ast::PathSegmentKind::CrateKw => break,
+            ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
+        }
+        path = path.qualifier()?;
+    }
+    res.reverse();
+    Some(res)
+}
+
+fn complete_local_name<'a>(
+    acc: &mut Vec<CompletionItem>,
+    file: &SourceFileNode,
+    name_ref: ast::NameRef<'a>,
+) -> Option<ast::FnDef<'a>> {
+    let mut enclosing_fn = None;
+    for node in name_ref.syntax().ancestors() {
+        if let Some(items) = visitor()
+            .visit::<ast::SourceFile, _>(|it| Some(it.items()))
+            .visit::<ast::Module, _>(|it| Some(it.item_list()?.items()))
+            .accept(node)
+        {
+            if let Some(items) = items {
+                complete_module_items(file, items, Some(name_ref), acc);
+            }
+            break;
+        } else if enclosing_fn.is_none() {
+            if let Some(fn_def) = ast::FnDef::cast(node) {
+                enclosing_fn = Some(fn_def);
+                let scopes = FnScopes::new(fn_def);
+                complete_fn(name_ref, &scopes, acc);
+            }
+        }
+    }
+    enclosing_fn
+}
+
+fn complete_module_items(
+    file: &SourceFileNode,
+    items: AstChildren<ast::ModuleItem>,
+    this_item: Option<ast::NameRef>,
+    acc: &mut Vec<CompletionItem>,
+) {
+    let scope = ModuleScope::new(items); // FIXME
+    acc.extend(
+        scope
+            .entries()
+            .iter()
+            .filter(|entry| {
+                let syntax = entry.ptr().resolve(file);
+                Some(syntax.borrowed()) != this_item.map(|it| it.syntax())
+            })
+            .map(|entry| CompletionItem {
+                label: entry.name().to_string(),
+                lookup: None,
+                snippet: None,
+            }),
+    );
+}
+
+fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
+    let mut shadowed = FxHashSet::default();
+    acc.extend(
+        scopes
+            .scope_chain(name_ref.syntax())
+            .flat_map(|scope| scopes.entries(scope).iter())
+            .filter(|entry| shadowed.insert(entry.name()))
+            .map(|entry| CompletionItem {
+                label: entry.name().to_string(),
+                lookup: None,
+                snippet: None,
+            }),
+    );
+    if scopes.self_param.is_some() {
+        acc.push(CompletionItem {
+            label: "self".to_string(),
+            lookup: None,
+            snippet: None,
+        })
+    }
+}
+
+fn complete_path(
+    acc: &mut Vec<CompletionItem>,
+    db: &RootDatabase,
+    file_id: FileId,
+    crate_path: Vec<ast::NameRef>,
+) -> Cancelable<()> {
+    let source_root_id = db.file_source_root(file_id);
+    let module_tree = db.module_tree(source_root_id)?;
+    let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
+        None => return Ok(()),
+        Some(it) => it,
+    };
+    let target_module_id = match find_target_module(&module_tree, module_id, crate_path) {
+        None => return Ok(()),
+        Some(it) => it,
+    };
+    let module_scope = db.module_scope(source_root_id, target_module_id)?;
+    let completions = module_scope.entries().iter().map(|entry| CompletionItem {
+        label: entry.name().to_string(),
+        lookup: None,
+        snippet: None,
+    });
+    acc.extend(completions);
+    Ok(())
+}
+
+fn find_target_module(
+    module_tree: &ModuleTree,
+    module_id: ModuleId,
+    mut crate_path: Vec<ast::NameRef>,
+) -> Option<ModuleId> {
+    crate_path.pop();
+    let mut target_module = module_id.root(&module_tree);
+    for name in crate_path {
+        target_module = target_module.child(module_tree, name.text().as_str())?;
+    }
+    Some(target_module)
+}
+
+fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
+    acc.push(CompletionItem {
+        label: "tfn".to_string(),
+        lookup: None,
+        snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
+    });
+    acc.push(CompletionItem {
+        label: "pub(crate)".to_string(),
+        lookup: None,
+        snippet: Some("pub(crate) $0".to_string()),
+    })
+}
+
+fn complete_expr_keywords(
+    file: &SourceFileNode,
+    fn_def: ast::FnDef,
+    name_ref: ast::NameRef,
+    acc: &mut Vec<CompletionItem>,
+) {
+    acc.push(keyword("if", "if $0 {}"));
+    acc.push(keyword("match", "match $0 {}"));
+    acc.push(keyword("while", "while $0 {}"));
+    acc.push(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.push(keyword("else", "else {$0}"));
+                acc.push(keyword("else if", "else if $0 {}"));
+            }
+        }
+    }
+    if is_in_loop_body(name_ref) {
+        acc.push(keyword("continue", "continue"));
+        acc.push(keyword("break", "break"));
+    }
+    acc.extend(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, snip: &str) -> CompletionItem {
+    CompletionItem {
+        label: kw.to_string(),
+        lookup: None,
+        snippet: Some(snip.to_string()),
+    }
+}
+
+fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
+    acc.push(CompletionItem {
+        label: "pd".to_string(),
+        lookup: None,
+        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
+    });
+    acc.push(CompletionItem {
+        label: "ppd".to_string(),
+        lookup: None,
+        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
+    });
+}
+
+