26 files changed, 556 insertions, 234 deletions
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 191104890..9405aa8ad 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -10,12 +10,13 @@ use crate::{
    nameres::{ModuleScope, lower::ImportId},
    db::HirDatabase,
    expr::BodySyntaxMapping,
-    ty::InferenceResult,
+    ty::{InferenceResult},
    adt::{EnumVariantId, StructFieldId, VariantDef},
    generics::GenericParams,
    docs::{Documentation, Docs, docs_from_ast},
    module_tree::ModuleId,
    ids::{FunctionId, StructId, EnumId, AstItemDef, ConstId, StaticId, TraitId, TypeId},
+    impl_block::ImplId,
 };
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -51,7 +52,7 @@ pub enum Def {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
-    pub(crate) krate: CrateId,
+    pub(crate) krate: Crate,
    pub(crate) module_id: ModuleId,
 }
@@ -126,9 +127,14 @@ impl Module {
        self.import_source_impl(db, import)
    }
+    /// Returns the syntax of the impl block in this module
+    pub fn impl_source(&self, db: &impl HirDatabase, impl_id: ImplId) -> TreeArc<ast::ImplBlock> {
+        self.impl_source_impl(db, impl_id)
+    }
    /// Returns the crate this module is part of.
-    pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
+    pub fn krate(&self, _db: &impl HirDatabase) -> Option<Crate> {
-        self.krate_impl(db)
+        Some(self.krate)
    }
    /// Topmost parent of this module. Every module has a `crate_root`, but some
@@ -272,6 +278,10 @@ impl Struct {
    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
        db.generic_params((*self).into())
    }
+    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
+        db.type_for_def((*self).into())
+    }
 }
 impl Docs for Struct {
@@ -317,6 +327,10 @@ impl Enum {
    pub fn generic_params(&self, db: &impl HirDatabase) -> Arc<GenericParams> {
        db.generic_params((*self).into())
    }
+    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
+        db.type_for_def((*self).into())
+    }
 }
 impl Docs for Enum {
@@ -382,7 +396,7 @@ pub struct Function {
    pub(crate) id: FunctionId,
 }
-pub use crate::code_model_impl::function::ScopeEntryWithSyntax;
+pub use crate::expr::ScopeEntryWithSyntax;
 /// The declared signature of a function.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -424,12 +438,16 @@ impl Function {
        self.id.module(db)
    }
+    pub fn name(&self, db: &impl HirDatabase) -> Name {
+        self.signature(db).name.clone()
+    }
    pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Arc<BodySyntaxMapping> {
        db.body_syntax_mapping(*self)
    }
    pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
-        let scopes = db.fn_scopes(*self);
+        let scopes = db.expr_scopes(*self);
        let syntax_mapping = db.body_syntax_mapping(*self);
        ScopesWithSyntaxMapping {
            scopes,
diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs
index e0dd4d629..422643996 100644
--- a/crates/ra_hir/src/code_model_impl/function.rs
+++ b/crates/ra_hir/src/code_model_impl/function.rs
@@ -1,5 +1,3 @@
-mod scope;
 use std::sync::Arc;
 use ra_syntax::ast::{self, NameOwner};
@@ -11,8 +9,6 @@ use crate::{
    impl_block::ImplBlock,
 };
-pub use self::scope::{FnScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
 impl Function {
    pub(crate) fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
        db.body_hir(*self)
diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
index cdd30b402..86f29d959 100644
--- a/crates/ra_hir/src/code_model_impl/krate.rs
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -1,31 +1,28 @@
-use ra_db::CrateId;
 use crate::{
    Crate, CrateDependency, AsName, Module,
    db::HirDatabase,
 };
 impl Crate {
-    pub(crate) fn new(crate_id: CrateId) -> Crate {
-        Crate { crate_id }
-    }
    pub(crate) fn dependencies_impl(&self, db: &impl HirDatabase) -> Vec<CrateDependency> {
        let crate_graph = db.crate_graph();
        crate_graph
            .dependencies(self.crate_id)
            .map(|dep| {
-                let krate = Crate::new(dep.crate_id());
+                let krate = Crate {
+                    crate_id: dep.crate_id(),
+                };
                let name = dep.as_name();
                CrateDependency { krate, name }
            })
            .collect()
    }
    pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Option<Module> {
-        let module_tree = db.module_tree(self.crate_id);
+        let module_tree = db.module_tree(*self);
        let module_id = module_tree.modules().next()?;
        let module = Module {
-            krate: self.crate_id,
+            krate: *self,
            module_id,
        };
        Some(module)
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 418d59c91..4a3901b8b 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -3,8 +3,9 @@ use ra_syntax::{ast, SyntaxNode, TreeArc};
 use crate::{
    Module, ModuleSource, Problem,
-    Crate, Name,
+    Name,
    module_tree::ModuleId,
+    impl_block::ImplId,
    nameres::{lower::ImportId},
    db::HirDatabase,
 };
@@ -51,13 +52,19 @@ impl Module {
        db: &impl HirDatabase,
        import: ImportId,
    ) -> TreeArc<ast::PathSegment> {
-        let source_map = db.lower_module_source_map(self.clone());
+        let source_map = db.lower_module_source_map(*self);
        let (_, source) = self.definition_source(db);
        source_map.get(&source, import)
    }
-    pub(crate) fn krate_impl(&self, _db: &impl HirDatabase) -> Option<Crate> {
+    pub(crate) fn impl_source_impl(
-        Some(Crate::new(self.krate))
+        &self,
+        db: &impl HirDatabase,
+        impl_id: ImplId,
+    ) -> TreeArc<ast::ImplBlock> {
+        let source_map = db.impls_in_module_source_map(*self);
+        let (_, source) = self.definition_source(db);
+        source_map.get(&source, impl_id)
    }
    pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Module {
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 3f76b769d..189649841 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,20 +1,20 @@
 use std::sync::Arc;
 use ra_syntax::{SyntaxNode, TreeArc, SourceFile};
-use ra_db::{SourceDatabase, CrateId, salsa};
+use ra_db::{SourceDatabase, salsa};
 use crate::{
    MacroCallId, HirFileId,
    SourceFileItems, SourceItemId, Crate, Module, HirInterner,
    query_definitions,
-    Function, FnSignature, FnScopes,
+    Function, FnSignature, ExprScopes,
    Struct, Enum, StructField,
    macros::MacroExpansion,
    module_tree::ModuleTree,
    nameres::{ItemMap, lower::{LoweredModule, ImportSourceMap}},
    ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef},
    adt::{StructData, EnumData},
-    impl_block::ModuleImplBlocks,
+    impl_block::{ModuleImplBlocks, ImplSourceMap},
    generics::{GenericParams, GenericDef},
    ids::SourceFileItemId,
 };
@@ -27,8 +27,8 @@ pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
    #[salsa::invoke(crate::macros::expand_macro_invocation)]
    fn expand_macro_invocation(&self, invoc: MacroCallId) -> Option<Arc<MacroExpansion>>;
-    #[salsa::invoke(query_definitions::fn_scopes)]
+    #[salsa::invoke(ExprScopes::expr_scopes_query)]
-    fn fn_scopes(&self, func: Function) -> Arc<FnScopes>;
+    fn expr_scopes(&self, func: Function) -> Arc<ExprScopes>;
    #[salsa::invoke(crate::adt::StructData::struct_data_query)]
    fn struct_data(&self, s: Struct) -> Arc<StructData>;
@@ -67,15 +67,24 @@ pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_source_map_query)]
    fn lower_module_source_map(&self, module: Module) -> Arc<ImportSourceMap>;
-    #[salsa::invoke(query_definitions::item_map)]
+    #[salsa::invoke(crate::nameres::ItemMap::item_map_query)]
-    fn item_map(&self, crate_id: CrateId) -> Arc<ItemMap>;
+    fn item_map(&self, krate: Crate) -> Arc<ItemMap>;
    #[salsa::invoke(crate::module_tree::ModuleTree::module_tree_query)]
-    fn module_tree(&self, crate_id: CrateId) -> Arc<ModuleTree>;
+    fn module_tree(&self, krate: Crate) -> Arc<ModuleTree>;
+    #[salsa::invoke(crate::impl_block::impls_in_module_with_source_map_query)]
+    fn impls_in_module_with_source_map(
+        &self,
+        module: Module,
+    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>);
    #[salsa::invoke(crate::impl_block::impls_in_module)]
    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
+    #[salsa::invoke(crate::impl_block::impls_in_module_source_map_query)]
+    fn impls_in_module_source_map(&self, module: Module) -> Arc<ImplSourceMap>;
    #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
    fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 60d997bbe..37aa24677 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -16,6 +16,10 @@ use crate::{
 };
 use crate::ty::primitive::{UintTy, UncertainIntTy, UncertainFloatTy};
+pub use self::scope::{ExprScopes, ScopesWithSyntaxMapping, ScopeEntryWithSyntax};
+mod scope;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ExprId(RawId);
 impl_arena_id!(ExprId);
@@ -215,7 +219,7 @@ pub use ra_syntax::ast::BinOp as BinaryOp;
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MatchArm {
    pub pats: Vec<PatId>,
-    // guard: Option<ExprId>, // TODO
+    pub guard: Option<ExprId>,
    pub expr: ExprId,
 }
@@ -511,10 +515,12 @@ impl ExprCollector {
                        MatchArm {
                            pats: vec![pat],
                            expr: then_branch,
+                            guard: None,
                        },
                        MatchArm {
                            pats: vec![placeholder_pat],
                            expr: else_branch,
+                            guard: None,
                        },
                    ];
                    self.alloc_expr(
@@ -613,6 +619,10 @@ impl ExprCollector {
                        .map(|arm| MatchArm {
                            pats: arm.pats().map(|p| self.collect_pat(p)).collect(),
                            expr: self.collect_expr_opt(arm.expr()),
+                            guard: arm
+                                .guard()
+                                .and_then(|guard| guard.expr())
+                                .map(|e| self.collect_expr(e)),
                        })
                        .collect()
                } else {
diff --git a/crates/ra_hir/src/code_model_impl/function/scope.rs b/crates/ra_hir/src/expr/scope.rs
index c5d1de5eb..f8b5ba581 100644
--- a/crates/ra_hir/src/code_model_impl/function/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -9,14 +9,18 @@ use ra_syntax::{
 };
 use ra_arena::{Arena, RawId, impl_arena_id};
-use crate::{Name, AsName, expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping}};
+use crate::{
+    Name, AsName, Function,
+    expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySyntaxMapping},
+    db::HirDatabase,
+};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ScopeId(RawId);
 impl_arena_id!(ScopeId);
 #[derive(Debug, PartialEq, Eq)]
-pub struct FnScopes {
+pub struct ExprScopes {
    body: Arc<Body>,
    scopes: Arena<ScopeId, ScopeData>,
    scope_for: FxHashMap<ExprId, ScopeId>,
@@ -34,9 +38,16 @@ pub struct ScopeData {
    entries: Vec<ScopeEntry>,
 }
-impl FnScopes {
+impl ExprScopes {
-    pub(crate) fn new(body: Arc<Body>) -> FnScopes {
+    // TODO: This should take something more general than Function
-        let mut scopes = FnScopes {
+    pub(crate) fn expr_scopes_query(db: &impl HirDatabase, function: Function) -> Arc<ExprScopes> {
+        let body = db.body_hir(function);
+        let res = ExprScopes::new(body);
+        Arc::new(res)
+    }
+    fn new(body: Arc<Body>) -> ExprScopes {
+        let mut scopes = ExprScopes {
            body: body.clone(),
            scopes: Arena::default(),
            scope_for: FxHashMap::default(),
@@ -119,7 +130,7 @@ impl FnScopes {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ScopesWithSyntaxMapping {
    pub syntax_mapping: Arc<BodySyntaxMapping>,
-    pub scopes: Arc<FnScopes>,
+    pub scopes: Arc<ExprScopes>,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -249,7 +260,7 @@ fn compute_block_scopes(
    statements: &[Statement],
    tail: Option<ExprId>,
    body: &Body,
-    scopes: &mut FnScopes,
+    scopes: &mut ExprScopes,
    mut scope: ScopeId,
 ) {
    for stmt in statements {
@@ -275,7 +286,7 @@ fn compute_block_scopes(
    }
 }
-fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut FnScopes, scope: ScopeId) {
+fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope: ScopeId) {
    scopes.set_scope(expr, scope);
    match &body[expr] {
        Expr::Block { statements, tail } => {
@@ -344,7 +355,7 @@ mod tests {
        let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
        let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
        let body_hir = expr::collect_fn_body_syntax(fn_def);
-        let scopes = FnScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
        let scopes = ScopesWithSyntaxMapping {
            scopes: Arc::new(scopes),
            syntax_mapping: Arc::new(body_hir),
@@ -444,7 +455,7 @@ mod tests {
        let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
        let body_hir = expr::collect_fn_body_syntax(fn_def);
-        let scopes = FnScopes::new(Arc::clone(body_hir.body()));
+        let scopes = ExprScopes::new(Arc::clone(body_hir.body()));
        let scopes = ScopesWithSyntaxMapping {
            scopes: Arc::new(scopes),
            syntax_mapping: Arc::new(body_hir),
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 222e47349..5fc26324a 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -1,8 +1,10 @@
 use std::sync::Arc;
 use rustc_hash::FxHashMap;
-use ra_arena::{Arena, RawId, impl_arena_id};
+use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
-use ra_syntax::ast::{self, AstNode};
+use ra_syntax::{
+    AstPtr, SourceFile, TreeArc,
+ast::{self, AstNode}};
 use crate::{
    Const, Type,
@@ -14,6 +16,26 @@ use crate::{
 use crate::code_model_api::{Module, ModuleSource};
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct ImplSourceMap {
+    map: ArenaMap<ImplId, AstPtr<ast::ImplBlock>>,
+}
+impl ImplSourceMap {
+    fn insert(&mut self, impl_id: ImplId, impl_block: &ast::ImplBlock) {
+        self.map.insert(impl_id, AstPtr::new(impl_block))
+    }
+    pub fn get(&self, source: &ModuleSource, impl_id: ImplId) -> TreeArc<ast::ImplBlock> {
+        let file = match source {
+            ModuleSource::SourceFile(file) => &*file,
+            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
+        };
+        self.map[impl_id].to_node(file).to_owned()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImplBlock {
    module_impl_blocks: Arc<ModuleImplBlocks>,
@@ -39,6 +61,10 @@ impl ImplBlock {
        }
    }
+    pub fn id(&self) -> ImplId {
+        self.impl_id
+    }
    fn impl_data(&self) -> &ImplData {
        &self.module_impl_blocks.impls[self.impl_id]
    }
@@ -148,7 +174,7 @@ impl ModuleImplBlocks {
        }
    }
-    fn collect(&mut self, db: &impl HirDatabase, module: Module) {
+    fn collect(&mut self, db: &impl HirDatabase, module: Module, source_map: &mut ImplSourceMap) {
        let (file_id, module_source) = module.definition_source(db);
        let file_id: HirFileId = file_id.into();
        let node = match &module_source {
@@ -165,12 +191,31 @@ impl ModuleImplBlocks {
            for &impl_item in &self.impls[id].items {
                self.impls_by_def.insert(impl_item, id);
            }
+            source_map.insert(id, impl_block_ast);
        }
    }
 }
-pub(crate) fn impls_in_module(db: &impl HirDatabase, module: Module) -> Arc<ModuleImplBlocks> {
+pub(crate) fn impls_in_module_with_source_map_query(
+    db: &impl HirDatabase,
+    module: Module,
+) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
+    let mut source_map = ImplSourceMap::default();
    let mut result = ModuleImplBlocks::new();
-    result.collect(db, module);
+    result.collect(db, module, &mut source_map);
-    Arc::new(result)
+    (Arc::new(result), Arc::new(source_map))
+}
+pub(crate) fn impls_in_module(db: &impl HirDatabase, module: Module) -> Arc<ModuleImplBlocks> {
+    db.impls_in_module_with_source_map(module).0
+}
+pub(crate) fn impls_in_module_source_map_query(
+    db: &impl HirDatabase,
+    module: Module,
+) -> Arc<ImplSourceMap> {
+    db.impls_in_module_with_source_map(module).1
 }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index eaf8565ee..0b9ee63bf 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -57,9 +57,9 @@ pub use self::{
    nameres::{ItemMap, PerNs, Namespace, Resolution},
    ty::Ty,
    impl_block::{ImplBlock, ImplItem},
-    code_model_impl::function::{FnScopes, ScopesWithSyntaxMapping},
    docs::{Docs, Documentation},
    adt::AdtDef,
+    expr::{ExprScopes, ScopesWithSyntaxMapping},
 };
 pub use self::code_model_api::{
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index d1dc3fa4b..1f327eeb2 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 use arrayvec::ArrayVec;
 use relative_path::RelativePathBuf;
-use ra_db::{FileId, SourceRoot, CrateId};
+use ra_db::{FileId, SourceRoot};
 use ra_syntax::{
    SyntaxNode, TreeArc,
    algo::generate,
@@ -13,6 +13,7 @@ use test_utils::tested_by;
 use crate::{
    Name, AsName, HirDatabase, SourceItemId, HirFileId, Problem, SourceFileItems, ModuleSource,
+    Crate,
    ids::SourceFileItemId,
 };
@@ -132,10 +133,10 @@ struct LinkData {
 }
 impl ModuleTree {
-    pub(crate) fn module_tree_query(db: &impl HirDatabase, crate_id: CrateId) -> Arc<ModuleTree> {
+    pub(crate) fn module_tree_query(db: &impl HirDatabase, krate: Crate) -> Arc<ModuleTree> {
        db.check_canceled();
        let mut res = ModuleTree::default();
-        res.init_crate(db, crate_id);
+        res.init_crate(db, krate);
        Arc::new(res)
    }
@@ -155,9 +156,9 @@ impl ModuleTree {
        Some(res)
    }
-    fn init_crate(&mut self, db: &impl HirDatabase, crate_id: CrateId) {
+    fn init_crate(&mut self, db: &impl HirDatabase, krate: Crate) {
        let crate_graph = db.crate_graph();
-        let file_id = crate_graph.crate_root(crate_id);
+        let file_id = crate_graph.crate_root(krate.crate_id);
        let source_root_id = db.file_source_root(file_id);
        let source_root = db.source_root(source_root_id);
@@ -172,6 +173,7 @@ impl ModuleTree {
        file_id: HirFileId,
        decl_id: Option<SourceFileItemId>,
    ) -> ModuleId {
+        let is_root = parent.is_none();
        let id = self.alloc_mod(ModuleData {
            file_id,
            decl_id,
@@ -191,7 +193,7 @@ impl ModuleTree {
            });
            let (points_to, problem) = if sub.is_declaration {
-                let (points_to, problem) = resolve_submodule(db, file_id, &sub.name);
+                let (points_to, problem) = resolve_submodule(db, file_id, &sub.name, is_root);
                let points_to = points_to
                    .into_iter()
                    .map(|file_id| {
@@ -295,6 +297,7 @@ fn resolve_submodule(
    db: &impl HirDatabase,
    file_id: HirFileId,
    name: &Name,
+    is_root: bool,
 ) -> (Vec<FileId>, Option<Problem>) {
    // FIXME: handle submodules of inline modules properly
    let file_id = file_id.original_file(db);
@@ -303,7 +306,7 @@ fn resolve_submodule(
    let root = RelativePathBuf::default();
    let dir_path = path.parent().unwrap_or(&root);
    let mod_name = path.file_stem().unwrap_or("unknown");
-    let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
+    let is_dir_owner = is_root || mod_name == "mod";
    let file_mod = dir_path.join(format!("{}.rs", name));
    let dir_mod = dir_path.join(format!("{}/mod.rs", name));
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 97ce6c946..4573a72ba 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -16,9 +16,8 @@
 //! structure itself is modified.
 pub(crate) mod lower;
-use std::sync::Arc;
+use std::{time, sync::Arc};
-use ra_db::CrateId;
 use ra_arena::map::ArenaMap;
 use test_utils::tested_by;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -156,10 +155,10 @@ impl<T> PerNs<T> {
    }
 }
-pub(crate) struct Resolver<'a, DB> {
+struct Resolver<'a, DB> {
    db: &'a DB,
    input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-    krate: CrateId,
+    krate: Crate,
    module_tree: Arc<ModuleTree>,
    processed_imports: FxHashSet<(ModuleId, ImportId)>,
    result: ItemMap,
@@ -169,10 +168,10 @@ impl<'a, DB> Resolver<'a, DB>
 where
    DB: HirDatabase,
 {
-    pub(crate) fn new(
+    fn new(
        db: &'a DB,
        input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-        krate: CrateId,
+        krate: Crate,
    ) -> Resolver<'a, DB> {
        let module_tree = db.module_tree(krate);
        Resolver {
@@ -219,7 +218,7 @@ where
            let crate_graph = self.db.crate_graph();
            if let Some(crate_id) = crate_graph.crate_id_for_crate_root(file_id.as_original_file())
            {
-                let krate = Crate::new(crate_id);
+                let krate = Crate { crate_id };
                for dep in krate.dependencies(self.db) {
                    if let Some(module) = dep.krate.root_module(self.db) {
                        let def = module.into();
@@ -331,6 +330,26 @@ enum ReachedFixedPoint {
 }
 impl ItemMap {
+    pub(crate) fn item_map_query(db: &impl HirDatabase, krate: Crate) -> Arc<ItemMap> {
+        let start = time::Instant::now();
+        let module_tree = db.module_tree(krate);
+        let input = module_tree
+            .modules()
+            .map(|module_id| {
+                (
+                    module_id,
+                    db.lower_module_module(Module { krate, module_id }),
+                )
+            })
+            .collect::<FxHashMap<_, _>>();
+        let resolver = Resolver::new(db, &input, krate);
+        let res = resolver.resolve();
+        let elapsed = start.elapsed();
+        log::info!("item_map: {:?}", elapsed);
+        Arc::new(res)
+    }
    pub(crate) fn resolve_path(
        &self,
        db: &impl HirDatabase,
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index e72781f51..9c5ca097e 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -16,7 +16,21 @@ fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
    let module = crate::source_binder::module_from_position(&db, pos).unwrap();
    let krate = module.krate(&db).unwrap();
    let module_id = module.module_id;
-    (db.item_map(krate.crate_id), module_id)
+    (db.item_map(krate), module_id)
+}
+/// Sets the crate root to the file of the cursor marker
+fn item_map_custom_crate_root(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
+    let (mut db, pos) = MockDatabase::with_position(fixture);
+    let mut crate_graph = CrateGraph::default();
+    crate_graph.add_crate_root(pos.file_id);
+    db.set_crate_graph(Arc::new(crate_graph));
+    let module = crate::source_binder::module_from_position(&db, pos).unwrap();
+    let krate = module.krate(&db).unwrap();
+    let module_id = module.module_id;
+    (db.item_map(krate), module_id)
 }
 fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
@@ -134,6 +148,28 @@ fn re_exports() {
 }
 #[test]
+fn module_resolution_works_for_non_standard_filenames() {
+    let (item_map, module_id) = item_map_custom_crate_root(
+        "
+        //- /my_library.rs
+        mod foo;
+        use self::foo::Bar;
+        <|>
+        //- /foo/mod.rs
+        pub struct Bar;
+    ",
+    );
+    check_module_item_map(
+        &item_map,
+        module_id,
+        "
+            Bar: t v
+            foo: t
+        ",
+    );
+}
+#[test]
 fn name_res_works_for_broken_modules() {
    covers!(name_res_works_for_broken_modules);
    let (item_map, module_id) = item_map(
@@ -261,7 +297,7 @@ fn item_map_across_crates() {
    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate.crate_id);
+    let item_map = db.item_map(krate);
    check_module_item_map(
        &item_map,
@@ -313,7 +349,7 @@ fn import_across_source_roots() {
    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate.crate_id);
+    let item_map = db.item_map(krate);
    check_module_item_map(
        &item_map,
@@ -355,7 +391,7 @@ fn reexport_across_crates() {
    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate.crate_id);
+    let item_map = db.item_map(krate);
    check_module_item_map(
        &item_map,
@@ -373,7 +409,7 @@ fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
    let krate = module.krate(&db).unwrap();
    {
        let events = db.log_executed(|| {
-            db.item_map(krate.crate_id);
+            db.item_map(krate);
        });
        assert!(format!("{:?}", events).contains("item_map"))
    }
@@ -381,7 +417,7 @@ fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
    {
        let events = db.log_executed(|| {
-            db.item_map(krate.crate_id);
+            db.item_map(krate);
        });
        assert!(
            !format!("{:?}", events).contains("item_map"),
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index bf9ac0dfb..734a98282 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -1,25 +1,14 @@
-use std::{
+use std::sync::Arc;
-    sync::Arc,
-    time::Instant,
-};
-use rustc_hash::FxHashMap;
+use ra_syntax::{
-use ra_syntax::{SyntaxNode, TreeArc};
+    SyntaxNode, TreeArc,
-use ra_db::{CrateId};
+};
 use crate::{
    SourceFileItems, SourceItemId, HirFileId,
-    Function, FnScopes, Module,
    db::HirDatabase,
-    nameres::{ItemMap, Resolver},
 };
-pub(super) fn fn_scopes(db: &impl HirDatabase, func: Function) -> Arc<FnScopes> {
-    let body = db.body_hir(func);
-    let res = FnScopes::new(body);
-    Arc::new(res)
-}
 pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
    let source_file = db.hir_parse(file_id);
    let res = SourceFileItems::new(file_id, &source_file);
@@ -35,26 +24,3 @@ pub(super) fn file_item(
        .to_node(&source_file)
        .to_owned()
 }
-pub(super) fn item_map(db: &impl HirDatabase, crate_id: CrateId) -> Arc<ItemMap> {
-    let start = Instant::now();
-    let module_tree = db.module_tree(crate_id);
-    let input = module_tree
-        .modules()
-        .map(|module_id| {
-            (
-                module_id,
-                db.lower_module_module(Module {
-                    krate: crate_id,
-                    module_id,
-                }),
-            )
-        })
-        .collect::<FxHashMap<_, _>>();
-    let resolver = Resolver::new(db, &input, crate_id);
-    let res = resolver.resolve();
-    let elapsed = start.elapsed();
-    log::info!("item_map: {:?}", elapsed);
-    Arc::new(res)
-}
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index f523f0647..d1eaccf23 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -13,8 +13,8 @@ use ra_syntax::{
 };
 use crate::{
-    HirDatabase, Function, ModuleDef,
+    HirDatabase, Function, ModuleDef, Struct, Enum,
-    AsName, Module, HirFileId,
+    AsName, Module, HirFileId, Crate,
    ids::{LocationCtx, SourceFileItemId},
 };
@@ -83,7 +83,8 @@ fn module_from_source(
    let source_root_id = db.file_source_root(file_id.as_original_file());
    db.source_root_crates(source_root_id)
        .iter()
-        .find_map(|&krate| {
+        .map(|&crate_id| Crate { crate_id })
+        .find_map(|krate| {
            let module_tree = db.module_tree(krate);
            let module_id = module_tree.find_module_by_source(file_id, decl_id)?;
            Some(Module { krate, module_id })
@@ -128,6 +129,28 @@ pub fn function_from_child_node(
    function_from_source(db, file_id, fn_def)
 }
+pub fn struct_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    struct_def: &ast::StructDef,
+) -> Struct {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Struct {
+        id: ctx.to_def(struct_def),
+    }
+}
+pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::EnumDef) -> Enum {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Enum {
+        id: ctx.to_def(enum_def),
+    }
+}
 pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, TextRange)> {
    let module = match module_from_file_id(db, file_id) {
        Some(it) => it,
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 31ea45706..60c231e82 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -20,6 +20,7 @@ mod tests;
 pub(crate) mod method_resolution;
 use std::borrow::Cow;
+use std::iter::repeat;
 use std::ops::Index;
 use std::sync::Arc;
 use std::{fmt, mem};
@@ -33,7 +34,7 @@ use test_utils::tested_by;
 use crate::{
    Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
-    FnSignature, FnScopes, ModuleDef, AdtDef,
+    FnSignature, ExprScopes, ModuleDef, AdtDef,
    db::HirDatabase,
    type_ref::{TypeRef, Mutability},
    name::KnownName,
@@ -185,7 +186,7 @@ pub enum Ty {
    /// Structures, enumerations and unions.
    Adt {
-        /// The DefId of the struct/enum.
+        /// The definition of the struct/enum.
        def_id: AdtDef,
        /// The name, for displaying.
        name: Name,
@@ -209,6 +210,27 @@ pub enum Ty {
    /// `&'a mut T` or `&'a T`.
    Ref(Arc<Ty>, Mutability),
+    /// The anonymous type of a function declaration/definition. Each
+    /// function has a unique type, which is output (for a function
+    /// named `foo` returning an `i32`) as `fn() -> i32 {foo}`.
+    ///
+    /// For example the type of `bar` here:
+    ///
+    /// ```rust
+    /// fn foo() -> i32 { 1 }
+    /// let bar = foo; // bar: fn() -> i32 {foo}
+    /// ```
+    FnDef {
+        // Function definition
+        def: Function,
+        /// For display
+        name: Name,
+        /// Parameters and return type
+        sig: Arc<FnSig>,
+        /// Substitutions for the generic parameters of the type
+        substs: Substs,
+    },
    /// A pointer to a function.  Written as `fn() -> i32`.
    ///
    /// For example the type of `bar` here:
@@ -448,12 +470,12 @@ impl Ty {
        }
        // add placeholders for args that were not provided
        // TODO: handle defaults
-        for _ in segment
+        let supplied_params = segment
            .args_and_bindings
            .as_ref()
            .map(|ga| ga.args.len())
-            .unwrap_or(0)..def_generics.params.len()
+            .unwrap_or(0);
-        {
+        for _ in supplied_params..def_generics.params.len() {
            substs.push(Ty::Unknown);
        }
        assert_eq!(substs.len(), def_generics.params.len());
@@ -485,6 +507,19 @@ impl Ty {
                }
                sig_mut.output.walk_mut(f);
            }
+            Ty::FnDef { substs, sig, .. } => {
+                let sig_mut = Arc::make_mut(sig);
+                for input in &mut sig_mut.input {
+                    input.walk_mut(f);
+                }
+                sig_mut.output.walk_mut(f);
+                // Without an Arc::make_mut_slice, we can't avoid the clone here:
+                let mut v: Vec<_> = substs.0.iter().cloned().collect();
+                for t in &mut v {
+                    t.walk_mut(f);
+                }
+                substs.0 = v.into();
+            }
            Ty::Adt { substs, .. } => {
                // Without an Arc::make_mut_slice, we can't avoid the clone here:
                let mut v: Vec<_> = substs.0.iter().cloned().collect();
@@ -524,6 +559,12 @@ impl Ty {
                name,
                substs,
            },
+            Ty::FnDef { def, name, sig, .. } => Ty::FnDef {
+                def,
+                name,
+                sig,
+                substs,
+            },
            _ => self,
        }
    }
@@ -551,7 +592,7 @@ impl Ty {
    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
    fn substs(&self) -> Option<Substs> {
        match self {
-            Ty::Adt { substs, .. } => Some(substs.clone()),
+            Ty::Adt { substs, .. } | Ty::FnDef { substs, .. } => Some(substs.clone()),
            _ => None,
        }
    }
@@ -586,6 +627,22 @@ impl fmt::Display for Ty {
                    .to_fmt(f)?;
                write!(f, " -> {}", sig.output)
            }
+            Ty::FnDef {
+                name, substs, sig, ..
+            } => {
+                write!(f, "fn {}", name)?;
+                if substs.0.len() > 0 {
+                    join(substs.0.iter())
+                        .surround_with("<", ">")
+                        .separator(", ")
+                        .to_fmt(f)?;
+                }
+                join(sig.input.iter())
+                    .surround_with("(", ")")
+                    .separator(", ")
+                    .to_fmt(f)?;
+                write!(f, " -> {}", sig.output)
+            }
            Ty::Adt { name, substs, .. } => {
                write!(f, "{}", name)?;
                if substs.0.len() > 0 {
@@ -607,11 +664,11 @@ impl fmt::Display for Ty {
 /// Compute the declared type of a function. This should not need to look at the
 /// function body.
-fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty {
+fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
-    let signature = f.signature(db);
+    let signature = def.signature(db);
-    let module = f.module(db);
+    let module = def.module(db);
-    let impl_block = f.impl_block(db);
+    let impl_block = def.impl_block(db);
-    let generics = f.generic_params(db);
+    let generics = def.generic_params(db);
    let input = signature
        .params()
        .iter()
@@ -624,8 +681,15 @@ fn type_for_fn(db: &impl HirDatabase, f: Function) -> Ty {
        &generics,
        signature.ret_type(),
    );
-    let sig = FnSig { input, output };
+    let sig = Arc::new(FnSig { input, output });
-    Ty::FnPtr(Arc::new(sig))
+    let substs = make_substs(&generics);
+    let name = def.name(db);
+    Ty::FnDef {
+        def,
+        sig,
+        name,
+        substs,
+    }
 }
 fn make_substs(generics: &GenericParams) -> Substs {
@@ -750,7 +814,7 @@ impl Index<PatId> for InferenceResult {
 struct InferenceContext<'a, D: HirDatabase> {
    db: &'a D,
    body: Arc<Body>,
-    scopes: Arc<FnScopes>,
+    scopes: Arc<ExprScopes>,
    module: Module,
    impl_block: Option<ImplBlock>,
    var_unification_table: InPlaceUnificationTable<TypeVarId>,
@@ -844,7 +908,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn new(
        db: &'a D,
        body: Arc<Body>,
-        scopes: Arc<FnScopes>,
+        scopes: Arc<ExprScopes>,
        module: Module,
        impl_block: Option<ImplBlock>,
    ) -> Self {
@@ -1102,7 +1166,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            .into();
        let typable = typable?;
        let ty = self.db.type_for_def(typable);
+        let generics = GenericParams::default();
+        let substs = Ty::substs_from_path(
+            self.db,
+            &self.module,
+            self.impl_block.as_ref(),
+            &generics,
+            path,
+            typable,
+        );
+        let ty = ty.apply_substs(substs);
        let ty = self.insert_type_vars(ty);
        Some(ty)
    }
@@ -1142,7 +1217,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let ty = self.insert_type_vars(ty.apply_substs(substs));
                (ty, Some(var.into()))
            }
-            TypableDef::Enum(_) | TypableDef::Function(_) => (Ty::Unknown, None),
+            TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None),
        }
    }
@@ -1196,9 +1271,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    Ty::Tuple(ref tuple_args) => &**tuple_args,
                    _ => &[],
                };
-                let expectations_iter = expectations
+                let expectations_iter = expectations.into_iter().chain(repeat(&Ty::Unknown));
-                    .into_iter()
-                    .chain(std::iter::repeat(&Ty::Unknown));
                let inner_tys = args
                    .iter()
@@ -1332,18 +1405,25 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            Expr::Call { callee, args } => {
                let callee_ty = self.infer_expr(*callee, &Expectation::none());
                let (param_tys, ret_ty) = match &callee_ty {
-                    Ty::FnPtr(sig) => (&sig.input[..], sig.output.clone()),
+                    Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()),
+                    Ty::FnDef { substs, sig, .. } => {
+                        let ret_ty = sig.output.clone().subst(&substs);
+                        let param_tys = sig
+                            .input
+                            .iter()
+                            .map(|ty| ty.clone().subst(&substs))
+                            .collect();
+                        (param_tys, ret_ty)
+                    }
                    _ => {
                        // not callable
                        // TODO report an error?
-                        (&[][..], Ty::Unknown)
+                        (Vec::new(), Ty::Unknown)
                    }
                };
-                for (i, arg) in args.iter().enumerate() {
+                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
-                    self.infer_expr(
+                for (arg, param) in args.iter().zip(param_iter) {
-                        *arg,
+                    self.infer_expr(*arg, &Expectation::has_type(param));
-                        &Expectation::has_type(param_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
-                    );
                }
                ret_ty
            }
@@ -1365,21 +1445,34 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {
                    Ty::FnPtr(sig) => {
                        if sig.input.len() > 0 {
-                            (&sig.input[0], &sig.input[1..], sig.output.clone())
+                            (
+                                sig.input[0].clone(),
+                                sig.input[1..].iter().cloned().collect(),
+                                sig.output.clone(),
+                            )
+                        } else {
+                            (Ty::Unknown, Vec::new(), sig.output.clone())
+                        }
+                    }
+                    Ty::FnDef { substs, sig, .. } => {
+                        let ret_ty = sig.output.clone().subst(&substs);
+                        if sig.input.len() > 0 {
+                            let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs));
+                            let receiver_ty = arg_iter.next().unwrap();
+                            (receiver_ty, arg_iter.collect(), ret_ty)
                        } else {
-                            (&Ty::Unknown, &[][..], sig.output.clone())
+                            (Ty::Unknown, Vec::new(), ret_ty)
                        }
                    }
-                    _ => (&Ty::Unknown, &[][..], Ty::Unknown),
+                    _ => (Ty::Unknown, Vec::new(), Ty::Unknown),
                };
                // TODO we would have to apply the autoderef/autoref steps here
                // to get the correct receiver type to unify...
-                self.unify(expected_receiver_ty, &receiver_ty);
+                self.unify(&expected_receiver_ty, &receiver_ty);
-                for (i, arg) in args.iter().enumerate() {
+                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
-                    self.infer_expr(
+                for (arg, param) in args.iter().zip(param_iter) {
-                        *arg,
+                    self.infer_expr(*arg, &Expectation::has_type(param));
-                        &Expectation::has_type(param_tys.get(i).cloned().unwrap_or(Ty::Unknown)),
-                    );
                }
                ret_ty
            }
@@ -1395,7 +1488,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    for &pat in &arm.pats {
                        let _pat_ty = self.infer_pat(pat, &input_ty);
                    }
-                    // TODO type the guard
+                    if let Some(guard_expr) = arm.guard {
+                        self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool));
+                    }
                    self.infer_expr(arm.expr, &expected);
                }
@@ -1468,9 +1563,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                cast_ty
            }
            Expr::Ref { expr, mutability } => {
-                // TODO pass the expectation down
+                let expectation = if let Ty::Ref(ref subty, expected_mutability) = expected.ty {
-                let inner_ty = self.infer_expr(*expr, &Expectation::none());
+                    if expected_mutability == Mutability::Mut && *mutability == Mutability::Shared {
+                        // TODO: throw type error - expected mut reference but found shared ref,
+                        // which cannot be coerced
+                    }
+                    Expectation::has_type((**subty).clone())
+                } else {
+                    Expectation::none()
+                };
                // TODO reference coercions etc.
+                let inner_ty = self.infer_expr(*expr, &expectation);
                Ty::Ref(Arc::new(inner_ty), *mutability)
            }
            Expr::UnaryOp { expr, op } => {
@@ -1495,9 +1598,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            _ => Ty::Unknown,
                        }
                    }
-                    UnaryOp::Not if inner_ty == Ty::Bool => Ty::Bool,
+                    UnaryOp::Not => {
-                    // TODO: resolve ops::Not trait for inner_ty
+                        match inner_ty {
-                    UnaryOp::Not => Ty::Unknown,
+                            Ty::Bool | Ty::Int(_) | Ty::Infer(InferTy::IntVar(..)) => inner_ty,
+                            // TODO: resolve ops::Not trait for inner_ty
+                            _ => Ty::Unknown,
+                        }
+                    }
                }
            }
            Expr::BinaryOp { lhs, rhs, op } => match op {
@@ -1609,10 +1716,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            self.infer_pat(*pat, &ty);
        }
-        self.return_ty = {
+        self.return_ty = self.make_ty(signature.ret_type());
-            let ty = self.make_ty(signature.ret_type());
-            ty
-        };
    }
    fn infer_body(&mut self) {
@@ -1626,7 +1730,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
    db.check_canceled();
    let body = func.body(db);
-    let scopes = db.fn_scopes(func);
+    let scopes = db.expr_scopes(func);
    let module = func.module(db);
    let impl_block = func.impl_block(db);
    let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 9a571c2aa..37bc3f38c 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -44,7 +44,7 @@ impl CrateImplBlocks {
        &'a self,
        db: &'a impl HirDatabase,
        ty: &Ty,
-    ) -> impl Iterator<Item = ImplBlock> + 'a {
+    ) -> impl Iterator<Item = (Module, ImplBlock)> + 'a {
        let fingerprint = TyFingerprint::for_impl(ty);
        fingerprint
            .and_then(|f| self.impls.get(&f))
@@ -52,11 +52,11 @@ impl CrateImplBlocks {
            .flat_map(|i| i.iter())
            .map(move |(module_id, impl_id)| {
                let module = Module {
-                    krate: self.krate.crate_id,
+                    krate: self.krate,
                    module_id: *module_id,
                };
                let module_impl_blocks = db.impls_in_module(module);
-                ImplBlock::from_id(module_impl_blocks, *impl_id)
+                (module, ImplBlock::from_id(module_impl_blocks, *impl_id))
            })
    }
@@ -152,7 +152,7 @@ impl Ty {
            };
            let impls = db.impls_in_crate(krate);
-            for impl_block in impls.lookup_impl_blocks(db, &derefed_ty) {
+            for (_, impl_block) in impls.lookup_impl_blocks(db, &derefed_ty) {
                for item in impl_block.items() {
                    match item {
                        ImplItem::Method(f) => {
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
index 2719f592e..48c83cbb2 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_adt_pattern.snap
@@ -1,10 +1,10 @@
 ---
-created: "2019-01-22T14:44:59.880187500+00:00"
+created: "2019-01-28T21:58:55.559331849+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
-[68; 262) '{     ...  d; }': ()
+[68; 289) '{     ...  d; }': ()
 [78; 79) 'e': E
 [82; 95) 'E::A { x: 3 }': E
 [92; 93) '3': usize
@@ -15,15 +15,18 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [129; 148) 'E::A {..._var }': E
 [139; 146) 'new_var': usize
 [151; 152) 'e': E
-[159; 218) 'match ...     }': usize
+[159; 245) 'match ...     }': usize
 [165; 166) 'e': E
 [177; 187) 'E::A { x }': E
 [184; 185) 'x': usize
 [191; 192) 'x': usize
 [202; 206) 'E::B': E
-[210; 211) '1': usize
+[210; 213) 'foo': bool
-[229; 248) 'ref d ...{ .. }': &E
+[217; 218) '1': usize
-[237; 248) 'E::A { .. }': E
+[228; 232) 'E::B': E
-[251; 252) 'e': E
+[236; 238) '10': usize
-[258; 259) 'd': &E
+[256; 275) 'ref d ...{ .. }': &E
+[264; 275) 'E::A { .. }': E
+[278; 279) 'e': E
+[285; 286) 'd': &E
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
index 3f2faa598..042248c35 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_array.snap
@@ -1,12 +1,12 @@
 ---
-created: "2019-01-22T14:44:59.880187500+00:00"
+created: "2019-01-30T20:08:05.185312835+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [9; 10) 'x': &str
 [18; 19) 'y': isize
-[28; 293) '{     ... []; }': ()
+[28; 324) '{     ... 3]; }': ()
 [38; 39) 'a': [&str]
 [42; 45) '[x]': [&str]
 [43; 44) 'x': &str
@@ -56,4 +56,10 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [260; 263) '"b"': &str
 [275; 276) 'x': [u8]
 [288; 290) '[]': [u8]
+[300; 301) 'z': &[u8]
+[311; 321) '&[1, 2, 3]': &[u8]
+[312; 321) '[1, 2, 3]': [u8]
+[313; 314) '1': u8
+[316; 317) '2': u8
+[319; 320) '3': u8
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap
index 5c74bd8c7..f5840a934 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_backwards.snap
@@ -1,8 +1,8 @@
 ---
-created: "2019-01-22T14:44:59.880187500+00:00"
+created: "2019-01-26T17:46:03.842478456+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [14; 15) 'x': u32
 [22; 24) '{}': ()
@@ -10,7 +10,7 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [88; 89) 'a': u32
 [92; 108) 'unknow...nction': [unknown]
 [92; 110) 'unknow...tion()': u32
-[116; 125) 'takes_u32': fn(u32) -> ()
+[116; 125) 'takes_u32': fn takes_u32(u32) -> ()
 [116; 128) 'takes_u32(a)': ()
 [126; 127) 'a': u32
 [138; 139) 'b': i32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap
index c506bcadd..b9dda2bc0 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_binary_op.snap
@@ -1,8 +1,8 @@
 ---
-created: "2019-01-22T14:44:59.880187500+00:00"
+created: "2019-01-26T17:46:03.853259898+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [6; 7) 'x': bool
 [22; 34) '{     0i32 }': i32
@@ -28,7 +28,7 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [174; 196) 'minus_...ONST_2': bool
 [189; 196) 'CONST_2': isize
 [206; 207) 'c': i32
-[210; 211) 'f': fn(bool) -> i32
+[210; 211) 'f': fn f(bool) -> i32
 [210; 219) 'f(z || y)': i32
 [210; 223) 'f(z || y) + 5': i32
 [212; 213) 'z': bool
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
index 7203ad1e2..8ff6e55a6 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_function_generics.snap
@@ -1,21 +1,21 @@
 ---
-created: "2019-01-22T14:44:59.954958500+00:00"
+created: "2019-01-26T18:16:16.530712344+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [10; 11) 't': [unknown]
 [21; 26) '{ t }': [unknown]
 [23; 24) 't': [unknown]
 [38; 98) '{     ...(1); }': ()
-[44; 46) 'id': fn(T) -> T
+[44; 46) 'id': fn id<u32>(T) -> T
-[44; 52) 'id(1u32)': T
+[44; 52) 'id(1u32)': u32
 [47; 51) '1u32': u32
-[58; 68) 'id::<i128>': fn(T) -> T
+[58; 68) 'id::<i128>': fn id<i128>(T) -> T
-[58; 71) 'id::<i128>(1)': T
+[58; 71) 'id::<i128>(1)': i128
-[69; 70) '1': T
+[69; 70) '1': i128
-[81; 82) 'x': T
+[81; 82) 'x': u64
-[90; 92) 'id': fn(T) -> T
+[90; 92) 'id': fn id<u64>(T) -> T
-[90; 95) 'id(1)': T
+[90; 95) 'id(1)': u64
-[93; 94) '1': T
+[93; 94) '1': u64
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
index 4435180a1..f21bffa75 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_generic_chain.snap
@@ -1,8 +1,8 @@
 ---
-created: "2019-01-22T14:44:59.961936900+00:00"
+created: "2019-01-26T17:46:03.866825843+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [53; 57) 'self': A<[unknown]>
 [65; 87) '{     ...     }': [unknown]
@@ -12,25 +12,25 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [110; 115) '{ t }': [unknown]
 [112; 113) 't': [unknown]
 [135; 261) '{     ....x() }': i128
-[146; 147) 'x': T
+[146; 147) 'x': i32
-[150; 151) '1': T
+[150; 151) '1': i32
-[162; 163) 'y': T
+[162; 163) 'y': i32
-[166; 168) 'id': fn(T) -> T
+[166; 168) 'id': fn id<i32>(T) -> T
-[166; 171) 'id(x)': T
+[166; 171) 'id(x)': i32
-[169; 170) 'x': T
+[169; 170) 'x': i32
-[182; 183) 'a': A<T>
+[182; 183) 'a': A<i32>
-[186; 200) 'A { x: id(y) }': A<T>
+[186; 200) 'A { x: id(y) }': A<i32>
-[193; 195) 'id': fn(T) -> T
+[193; 195) 'id': fn id<i32>(T) -> T
-[193; 198) 'id(y)': T
+[193; 198) 'id(y)': i32
-[196; 197) 'y': T
+[196; 197) 'y': i32
-[211; 212) 'z': T
+[211; 212) 'z': i32
-[215; 217) 'id': fn(T) -> T
+[215; 217) 'id': fn id<i32>(T) -> T
-[215; 222) 'id(a.x)': T
+[215; 222) 'id(a.x)': i32
-[218; 219) 'a': A<T>
+[218; 219) 'a': A<i32>
-[218; 221) 'a.x': T
+[218; 221) 'a.x': i32
-[233; 234) 'b': A<T>
+[233; 234) 'b': A<i32>
-[237; 247) 'A { x: z }': A<T>
+[237; 247) 'A { x: z }': A<i32>
-[244; 245) 'z': T
+[244; 245) 'z': i32
-[254; 255) 'b': A<T>
+[254; 255) 'b': A<i32>
 [254; 259) 'b.x()': i128
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap
index 0bceffaef..afbe2f747 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_paths.snap
@@ -1,16 +1,16 @@
 ---
-created: "2019-01-22T14:44:59.975899500+00:00"
+created: "2019-01-26T17:46:03.928773630+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [15; 20) '{ 1 }': u32
 [17; 18) '1': u32
 [48; 53) '{ 1 }': u32
 [50; 51) '1': u32
 [67; 91) '{     ...c(); }': ()
-[73; 74) 'a': fn() -> u32
+[73; 74) 'a': fn a() -> u32
 [73; 76) 'a()': u32
-[82; 86) 'b::c': fn() -> u32
+[82; 86) 'b::c': fn c() -> u32
 [82; 88) 'b::c()': u32
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
new file mode 100644
index 000000000..a99323264
--- /dev/null
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_type_param.snap
@@ -0,0 +1,26 @@
+---
+created: "2019-01-27T16:54:18.368427685+00:00"
+creator: [email protected]
+expression: "&result"
+source: crates/ra_hir/src/ty/tests.rs
+---
+[10; 11) 'x': [unknown]
+[21; 30) '{     x }': [unknown]
+[27; 28) 'x': [unknown]
+[44; 45) 'x': &[unknown]
+[56; 65) '{     x }': &[unknown]
+[62; 63) 'x': &[unknown]
+[77; 157) '{     ...(1); }': ()
+[87; 88) 'y': u32
+[91; 96) '10u32': u32
+[102; 104) 'id': fn id<u32>(T) -> T
+[102; 107) 'id(y)': u32
+[105; 106) 'y': u32
+[117; 118) 'x': bool
+[127; 132) 'clone': fn clone<bool>(&T) -> T
+[127; 135) 'clone(z)': bool
+[133; 134) 'z': &bool
+[141; 151) 'id::<i128>': fn id<i128>(T) -> T
+[141; 154) 'id::<i128>(1)': i128
+[152; 153) '1': i128
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap
index 10aa61954..5021d0eeb 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_unary_op.snap
@@ -1,11 +1,11 @@
 ---
-created: "2019-01-22T14:45:00.059676600+00:00"
+created: "2019-01-28T14:51:16.185273502+00:00"
-creator: insta@0.4.0
+creator: insta@0.5.2
 expression: "&result"
-source: "crates\\ra_hir\\src\\ty\\tests.rs"
+source: crates/ra_hir/src/ty/tests.rs
 ---
 [27; 28) 'x': SomeType
-[40; 197) '{     ...lo"; }': ()
+[40; 272) '{     ...lo"; }': ()
 [50; 51) 'b': bool
 [54; 59) 'false': bool
 [69; 70) 'c': bool
@@ -24,12 +24,25 @@ source: "crates\\ra_hir\\src\\ty\\tests.rs"
 [147; 153) '!!true': bool
 [148; 153) '!true': bool
 [149; 153) 'true': bool
-[159; 164) '-3.14': f64
+[163; 164) 'g': i32
-[160; 164) '3.14': f64
+[167; 170) '!42': i32
-[170; 172) '-x': [unknown]
+[168; 170) '42': i32
-[171; 172) 'x': SomeType
+[180; 181) 'h': u32
-[178; 180) '!x': [unknown]
+[184; 190) '!10u32': u32
-[179; 180) 'x': SomeType
+[185; 190) '10u32': u32
-[186; 194) '-"hello"': [unknown]
+[200; 201) 'j': i128
-[187; 194) '"hello"': &str
+[204; 206) '!a': i128
+[205; 206) 'a': i128
+[212; 217) '-3.14': f64
+[213; 217) '3.14': f64
+[223; 225) '!3': i32
+[224; 225) '3': i32
+[231; 233) '-x': [unknown]
+[232; 233) 'x': SomeType
+[239; 241) '!x': [unknown]
+[240; 241) 'x': SomeType
+[247; 255) '-"hello"': [unknown]
+[248; 255) '"hello"': &str
+[261; 269) '!"hello"': [unknown]
+[262; 269) '"hello"': &str
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index f74d6f5ea..cb8d6351d 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -166,10 +166,15 @@ fn test(x: SomeType) {
    let d: i128 = -a;
    let e = -100;
    let f = !!!true;
+    let g = !42;
+    let h = !10u32;
+    let j = !a;
    -3.14;
+    !3;
    -x;
    !x;
    -"hello";
+    !"hello";
 }
 "#,
    );
@@ -366,6 +371,7 @@ fn test(x: &str, y: isize) {
    let b = [a, ["b"]];
    let x: [u8; 0] = [];
+    let z: &[u8] = &[1, 2, 3];
 }
 "#,
    );
@@ -421,7 +427,8 @@ fn test() {
    match e {
        E::A { x } => x,
-        E::B => 1,
+        E::B if foo => 1,
+        E::B => 10,
    };
    let ref d @ E::A { .. } = e;
@@ -594,6 +601,29 @@ fn test() {
    );
 }
+#[test]
+fn infer_type_param() {
+    check_inference(
+        "infer_type_param",
+        r#"
+fn id<T>(x: T) -> T {
+    x
+}
+fn clone<T>(x: &T) -> T {
+    x
+}
+fn test() {
+    let y = 10u32;
+    id(y);
+    let x: bool = clone(z);
+    id::<i128>(1);
+}
+"#,
+    );
+}
 fn infer(content: &str) -> String {
    let (db, _, file_id) = MockDatabase::with_single_file(content);
    let source_file = db.parse(file_id);