14 files changed, 330 insertions, 138 deletions

diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index 78ea8976b..e027eedd9 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use ra_arena::{RawId, Arena, impl_arena_id};
 use ra_syntax::{
     TreeArc,
-    ast::{self, NameOwner, StructFlavor, TypeAscriptionOwner}
+    ast::{self, NameOwner, StructKind, TypeAscriptionOwner}
 };
 
 use crate::{
@@ -47,7 +47,7 @@ pub struct StructData {
 impl StructData {
     fn new(struct_def: &ast::StructDef) -> StructData {
         let name = struct_def.name().map(|n| n.as_name());
-        let variant_data = VariantData::new(struct_def.flavor());
+        let variant_data = VariantData::new(struct_def.kind());
         let variant_data = Arc::new(variant_data);
         StructData { name, variant_data }
     }
@@ -94,7 +94,7 @@ impl EnumData {
         let variants = variants(&*enum_def)
             .map(|var| EnumVariantData {
                 name: var.name().map(|it| it.as_name()),
-                variant_data: Arc::new(VariantData::new(var.flavor())),
+                variant_data: Arc::new(VariantData::new(var.kind())),
             })
             .collect();
         Arc::new(EnumData { name, variants })
@@ -143,9 +143,9 @@ impl VariantData {
 }
 
 impl VariantData {
-    fn new(flavor: StructFlavor) -> Self {
+    fn new(flavor: StructKind) -> Self {
         let inner = match flavor {
-            ast::StructFlavor::Tuple(fl) => {
+            ast::StructKind::Tuple(fl) => {
                 let fields = fl
                     .fields()
                     .enumerate()
@@ -156,7 +156,7 @@ impl VariantData {
                     .collect();
                 VariantDataInner::Tuple(fields)
             }
-            ast::StructFlavor::Named(fl) => {
+            ast::StructKind::Named(fl) => {
                 let fields = fl
                     .fields()
                     .map(|fd| StructFieldData {
@@ -166,7 +166,7 @@ impl VariantData {
                     .collect();
                 VariantDataInner::Struct(fields)
             }
-            ast::StructFlavor::Unit => VariantDataInner::Unit,
+            ast::StructKind::Unit => VariantDataInner::Unit,
         };
         VariantData(inner)
     }
@@ -200,27 +200,27 @@ impl StructField {
         let fields = var_data.fields().unwrap();
         let ss;
         let es;
-        let (file_id, struct_flavor) = match self.parent {
+        let (file_id, struct_kind) = match self.parent {
             VariantDef::Struct(s) => {
                 let (file_id, source) = s.source(db);
                 ss = source;
-                (file_id, ss.flavor())
+                (file_id, ss.kind())
             }
             VariantDef::EnumVariant(e) => {
                 let (file_id, source) = e.source(db);
                 es = source;
-                (file_id, es.flavor())
+                (file_id, es.kind())
             }
         };
 
-        let field_sources = match struct_flavor {
-            ast::StructFlavor::Tuple(fl) => {
+        let field_sources = match struct_kind {
+            ast::StructKind::Tuple(fl) => {
                 fl.fields().map(|it| FieldSource::Pos(it.to_owned())).collect()
             }
-            ast::StructFlavor::Named(fl) => {
+            ast::StructKind::Named(fl) => {
                 fl.fields().map(|it| FieldSource::Named(it.to_owned())).collect()
             }
-            ast::StructFlavor::Unit => Vec::new(),
+            ast::StructKind::Unit => Vec::new(),
         };
         let field = field_sources
             .into_iter()
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 624c25c4d..9e6170440 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -4,7 +4,7 @@ use ra_db::{CrateId, SourceRootId, Edition};
 use ra_syntax::{ast::self, TreeArc};
 
 use crate::{
-    Name, ScopesWithSourceMap, Ty, HirFileId,
+    Name, ScopesWithSourceMap, Ty, HirFileId, ImportSource,
     HirDatabase, DefDatabase,
     type_ref::TypeRef,
     nameres::{ModuleScope, Namespace, ImportId, CrateModuleId},
@@ -117,11 +117,7 @@ impl Module {
     }
 
     /// Returns the syntax of the last path segment corresponding to this import
-    pub fn import_source(
-        &self,
-        db: &impl HirDatabase,
-        import: ImportId,
-    ) -> TreeArc<ast::PathSegment> {
+    pub fn import_source(&self, db: &impl HirDatabase, import: ImportId) -> ImportSource {
         self.import_source_impl(db, import)
     }
 
@@ -433,6 +429,45 @@ impl Docs for EnumVariant {
     }
 }
 
+/// The defs which have a body.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DefWithBody {
+    Function(Function),
+    Const(Const),
+    Static(Static),
+}
+
+impl_froms!(DefWithBody: Function, Const, Static);
+
+impl DefWithBody {
+    pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer(*self)
+    }
+
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map(*self).1
+    }
+
+    pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
+        db.body_hir(*self)
+    }
+
+    /// Builds a resolver for code inside this item.
+    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        match *self {
+            DefWithBody::Const(ref c) => c.resolver(db),
+            DefWithBody::Function(ref f) => f.resolver(db),
+            DefWithBody::Static(ref s) => s.resolver(db),
+        }
+    }
+
+    pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSourceMap {
+        let scopes = db.expr_scopes(*self);
+        let source_map = db.body_with_source_map(*self).1;
+        ScopesWithSourceMap { scopes, source_map }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Function {
     pub(crate) id: FunctionId,
@@ -483,11 +518,11 @@ impl Function {
     }
 
     pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_with_source_map(*self).1
+        db.body_with_source_map((*self).into()).1
     }
 
     pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body_hir(*self)
+        db.body_hir((*self).into())
     }
 
     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
@@ -495,8 +530,8 @@ impl Function {
     }
 
     pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSourceMap {
-        let scopes = db.expr_scopes(*self);
-        let source_map = db.body_with_source_map(*self).1;
+        let scopes = db.expr_scopes((*self).into());
+        let source_map = db.body_with_source_map((*self).into()).1;
         ScopesWithSourceMap { scopes, source_map }
     }
 
@@ -505,7 +540,7 @@ impl Function {
     }
 
     pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(*self)
+        db.infer((*self).into())
     }
 
     pub fn generic_params(&self, db: &impl DefDatabase) -> Arc<GenericParams> {
@@ -561,6 +596,14 @@ impl Const {
         db.const_signature(*self)
     }
 
+    pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer((*self).into())
+    }
+
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map((*self).into()).1
+    }
+
     /// The containing impl block, if this is a method.
     pub fn impl_block(&self, db: &impl DefDatabase) -> Option<ImplBlock> {
         let module_impls = db.impls_in_module(self.module(db));
@@ -625,6 +668,14 @@ impl Static {
         // take the outer scope...
         self.module(db).resolver(db)
     }
+
+    pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer((*self).into())
+    }
+
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map((*self).into()).1
+    }
 }
 
 impl Docs for Static {
diff --git a/crates/ra_hir/src/code_model_impl/function.rs b/crates/ra_hir/src/code_model_impl/function.rs
index 334cb302b..f8bd0f784 100644
--- a/crates/ra_hir/src/code_model_impl/function.rs
+++ b/crates/ra_hir/src/code_model_impl/function.rs
@@ -20,12 +20,12 @@ impl FnSignature {
                     TypeRef::from_ast(type_ref)
                 } else {
                     let self_type = TypeRef::Path(Name::self_type().into());
-                    match self_param.flavor() {
-                        ast::SelfParamFlavor::Owned => self_type,
-                        ast::SelfParamFlavor::Ref => {
+                    match self_param.kind() {
+                        ast::SelfParamKind::Owned => self_type,
+                        ast::SelfParamKind::Ref => {
                             TypeRef::Reference(Box::new(self_type), Mutability::Shared)
                         }
-                        ast::SelfParamFlavor::MutRef => {
+                        ast::SelfParamKind::MutRef => {
                             TypeRef::Reference(Box::new(self_type), Mutability::Mut)
                         }
                     }
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 0edb8ade5..88dee3a69 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -5,7 +5,7 @@ use crate::{
     Module, ModuleSource, Name, AstId,
     nameres::{CrateModuleId, ImportId},
     HirDatabase, DefDatabase,
-    HirFileId,
+    HirFileId, ImportSource,
 };
 
 impl ModuleSource {
@@ -72,7 +72,7 @@ impl Module {
         &self,
         db: &impl HirDatabase,
         import: ImportId,
-    ) -> TreeArc<ast::PathSegment> {
+    ) -> ImportSource {
         let (file_id, source) = self.definition_source(db);
         let (_, source_map) = db.raw_items_with_source_map(file_id);
         source_map.get(&source, import)
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 147005848..be8a8c98b 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -8,6 +8,7 @@ use crate::{
     Function, FnSignature, ExprScopes, TypeAlias,
     Struct, Enum, StructField,
     Const, ConstSignature, Static,
+    DefWithBody,
     nameres::{Namespace, ImportSourceMap, RawItems, CrateDefMap},
     ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef, CallableDef, FnSig},
     adt::{StructData, EnumData},
@@ -83,10 +84,10 @@ pub trait DefDatabase: SourceDatabase + AsRef<HirInterner> {
 #[salsa::query_group(HirDatabaseStorage)]
 pub trait HirDatabase: DefDatabase {
     #[salsa::invoke(ExprScopes::expr_scopes_query)]
-    fn expr_scopes(&self, func: Function) -> Arc<ExprScopes>;
+    fn expr_scopes(&self, def: DefWithBody) -> Arc<ExprScopes>;
 
     #[salsa::invoke(crate::ty::infer)]
-    fn infer(&self, func: Function) -> Arc<InferenceResult>;
+    fn infer(&self, def: DefWithBody) -> Arc<InferenceResult>;
 
     #[salsa::invoke(crate::ty::type_for_def)]
     fn type_for_def(&self, def: TypableDef, ns: Namespace) -> Ty;
@@ -100,11 +101,11 @@ pub trait HirDatabase: DefDatabase {
     #[salsa::invoke(crate::expr::body_with_source_map_query)]
     fn body_with_source_map(
         &self,
-        func: Function,
+        def: DefWithBody,
     ) -> (Arc<crate::expr::Body>, Arc<crate::expr::BodySourceMap>);
 
     #[salsa::invoke(crate::expr::body_hir_query)]
-    fn body_hir(&self, func: Function) -> Arc<crate::expr::Body>;
+    fn body_hir(&self, def: DefWithBody) -> Arc<crate::expr::Body>;
 
     #[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 a85422955..b2a237ece 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -6,11 +6,11 @@ use rustc_hash::FxHashMap;
 use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
 use ra_syntax::{
     SyntaxNodePtr, AstPtr, AstNode,
-    ast::{self, LoopBodyOwner, ArgListOwner, NameOwner, LiteralFlavor, TypeAscriptionOwner}
+    ast::{self, LoopBodyOwner, ArgListOwner, NameOwner, LiteralKind, TypeAscriptionOwner}
 };
 
 use crate::{
-    Path, Name, HirDatabase, Function, Resolver,
+    Path, Name, HirDatabase, Resolver,DefWithBody,
     name::AsName,
     type_ref::{Mutability, TypeRef},
 };
@@ -27,9 +27,8 @@ impl_arena_id!(ExprId);
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq)]
 pub struct Body {
-    // FIXME: this should be more general, consts & statics also have bodies
-    /// The Function of the item this body belongs to
-    owner: Function,
+    /// The def of the item this body belongs to
+    owner: DefWithBody,
     exprs: Arena<ExprId, Expr>,
     pats: Arena<PatId, Pat>,
     /// The patterns for the function's parameters. While the parameter types are
@@ -66,7 +65,7 @@ impl Body {
         self.body_expr
     }
 
-    pub fn owner(&self) -> Function {
+    pub fn owner(&self) -> DefWithBody {
         self.owner
     }
 
@@ -463,8 +462,8 @@ impl Pat {
 
 // Queries
 
-struct ExprCollector {
-    owner: Function,
+pub(crate) struct ExprCollector {
+    owner: DefWithBody,
     exprs: Arena<ExprId, Expr>,
     pats: Arena<PatId, Pat>,
     source_map: BodySourceMap,
@@ -473,7 +472,7 @@ struct ExprCollector {
 }
 
 impl ExprCollector {
-    fn new(owner: Function) -> Self {
+    fn new(owner: DefWithBody) -> Self {
         ExprCollector {
             owner,
             exprs: Arena::default(),
@@ -516,8 +515,8 @@ impl ExprCollector {
                     let else_branch = e
                         .else_branch()
                         .map(|b| match b {
-                            ast::ElseBranchFlavor::Block(it) => self.collect_block(it),
-                            ast::ElseBranchFlavor::IfExpr(elif) => {
+                            ast::ElseBranch::Block(it) => self.collect_block(it),
+                            ast::ElseBranch::IfExpr(elif) => {
                                 let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
                                 self.collect_expr(expr)
                             }
@@ -533,8 +532,8 @@ impl ExprCollector {
                     let condition = self.collect_expr_opt(e.condition().and_then(|c| c.expr()));
                     let then_branch = self.collect_block_opt(e.then_branch());
                     let else_branch = e.else_branch().map(|b| match b {
-                        ast::ElseBranchFlavor::Block(it) => self.collect_block(it),
-                        ast::ElseBranchFlavor::IfExpr(elif) => {
+                        ast::ElseBranch::Block(it) => self.collect_block(it),
+                        ast::ElseBranch::IfExpr(elif) => {
                             let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap();
                             self.collect_expr(expr)
                         }
@@ -726,14 +725,8 @@ impl ExprCollector {
                 self.alloc_expr(Expr::Array { exprs }, syntax_ptr)
             }
             ast::ExprKind::Literal(e) => {
-                let child = if let Some(child) = e.literal_expr() {
-                    child
-                } else {
-                    return self.alloc_expr(Expr::Missing, syntax_ptr);
-                };
-
-                let lit = match child.flavor() {
-                    LiteralFlavor::IntNumber { suffix } => {
+                let lit = match e.kind() {
+                    LiteralKind::IntNumber { suffix } => {
                         let known_name = suffix
                             .and_then(|it| IntTy::from_suffix(&it).map(UncertainIntTy::Known));
 
@@ -742,7 +735,7 @@ impl ExprCollector {
                             known_name.unwrap_or(UncertainIntTy::Unknown),
                         )
                     }
-                    LiteralFlavor::FloatNumber { suffix } => {
+                    LiteralKind::FloatNumber { suffix } => {
                         let known_name = suffix
                             .and_then(|it| FloatTy::from_suffix(&it).map(UncertainFloatTy::Known));
 
@@ -751,13 +744,13 @@ impl ExprCollector {
                             known_name.unwrap_or(UncertainFloatTy::Unknown),
                         )
                     }
-                    LiteralFlavor::ByteString => Literal::ByteString(Default::default()),
-                    LiteralFlavor::String => Literal::String(Default::default()),
-                    LiteralFlavor::Byte => {
+                    LiteralKind::ByteString => Literal::ByteString(Default::default()),
+                    LiteralKind::String => Literal::String(Default::default()),
+                    LiteralKind::Byte => {
                         Literal::Int(Default::default(), UncertainIntTy::Known(IntTy::u8()))
                     }
-                    LiteralFlavor::Bool => Literal::Bool(Default::default()),
-                    LiteralFlavor::Char => Literal::Char(Default::default()),
+                    LiteralKind::Bool => Literal::Bool(Default::default()),
+                    LiteralKind::Char => Literal::Char(Default::default()),
                 };
                 self.alloc_expr(Expr::Literal(lit), syntax_ptr)
             }
@@ -766,6 +759,7 @@ impl ExprCollector {
             ast::ExprKind::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
             ast::ExprKind::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
             ast::ExprKind::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::MacroCall(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
         }
     }
 
@@ -871,12 +865,20 @@ impl ExprCollector {
         }
     }
 
+    fn collect_const_body(&mut self, node: &ast::ConstDef) {
+        let body = self.collect_expr_opt(node.body());
+        self.body_expr = Some(body);
+    }
+
+    fn collect_static_body(&mut self, node: &ast::StaticDef) {
+        let body = self.collect_expr_opt(node.body());
+        self.body_expr = Some(body);
+    }
+
     fn collect_fn_body(&mut self, node: &ast::FnDef) {
         if let Some(param_list) = node.param_list() {
             if let Some(self_param) = param_list.self_param() {
-                let self_param = SyntaxNodePtr::new(
-                    self_param.self_kw().expect("self param without self keyword").syntax(),
-                );
+                let self_param = SyntaxNodePtr::new(self_param.syntax());
                 let param_pat = self.alloc_pat(
                     Pat::Bind {
                         name: Name::self_param(),
@@ -917,24 +919,20 @@ impl ExprCollector {
 
 pub(crate) fn body_with_source_map_query(
     db: &impl HirDatabase,
-    func: Function,
+    def: DefWithBody,
 ) -> (Arc<Body>, Arc<BodySourceMap>) {
-    let mut collector = ExprCollector::new(func);
+    let mut collector = ExprCollector::new(def);
 
-    // FIXME: consts, etc.
-    collector.collect_fn_body(&func.source(db).1);
+    match def {
+        DefWithBody::Const(ref c) => collector.collect_const_body(&c.source(db).1),
+        DefWithBody::Function(ref f) => collector.collect_fn_body(&f.source(db).1),
+        DefWithBody::Static(ref s) => collector.collect_static_body(&s.source(db).1),
+    }
 
     let (body, source_map) = collector.finish();
     (Arc::new(body), Arc::new(source_map))
 }
 
-pub(crate) fn body_hir_query(db: &impl HirDatabase, func: Function) -> Arc<Body> {
-    db.body_with_source_map(func).0
-}
-
-#[cfg(test)]
-fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> (Body, BodySourceMap) {
-    let mut collector = ExprCollector::new(function);
-    collector.collect_fn_body(node);
-    collector.finish()
+pub(crate) fn body_hir_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<Body> {
+    db.body_with_source_map(def).0
 }
diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs
index ed005c9f7..48283907b 100644
--- a/crates/ra_hir/src/expr/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -10,7 +10,7 @@ use ra_syntax::{
 use ra_arena::{Arena, RawId, impl_arena_id};
 
 use crate::{
-    Name, AsName, Function,
+    Name, AsName,DefWithBody,
     expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySourceMap},
     HirDatabase,
 };
@@ -40,8 +40,8 @@ pub struct ScopeData {
 
 impl ExprScopes {
     // FIXME: This should take something more general than Function
-    pub(crate) fn expr_scopes_query(db: &impl HirDatabase, function: Function) -> Arc<ExprScopes> {
-        let body = db.body_hir(function);
+    pub(crate) fn expr_scopes_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<ExprScopes> {
+        let body = db.body_hir(def);
         let res = ExprScopes::new(body);
         Arc::new(res)
     }
@@ -297,8 +297,9 @@ mod tests {
     use ra_syntax::{SourceFile, algo::find_node_at_offset};
     use test_utils::{extract_offset, assert_eq_text};
     use ra_arena::ArenaId;
+    use crate::Function;
 
-    use crate::expr;
+    use crate::expr::{ExprCollector};
 
     use super::*;
 
@@ -316,7 +317,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 irrelevant_function = Function { id: crate::ids::FunctionId::from_raw(0.into()) };
-        let (body, source_map) = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
+        let (body, source_map) = collect_fn_body_syntax(irrelevant_function, fn_def);
         let scopes = ExprScopes::new(Arc::new(body));
         let scopes =
             ScopesWithSourceMap { scopes: Arc::new(scopes), source_map: Arc::new(source_map) };
@@ -405,6 +406,12 @@ mod tests {
         );
     }
 
+    fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> (Body, BodySourceMap) {
+        let mut collector = ExprCollector::new(DefWithBody::Function(function));
+        collector.collect_fn_body(node);
+        collector.finish()
+    }
+
     fn do_check_local_name(code: &str, expected_offset: u32) {
         let (off, code) = extract_offset(code);
         let file = SourceFile::parse(&code);
@@ -415,7 +422,7 @@ mod tests {
         let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
 
         let irrelevant_function = Function { id: crate::ids::FunctionId::from_raw(0.into()) };
-        let (body, source_map) = expr::collect_fn_body_syntax(irrelevant_function, fn_def);
+        let (body, source_map) = collect_fn_body_syntax(irrelevant_function, fn_def);
         let scopes = ExprScopes::new(Arc::new(body));
         let scopes =
             ScopesWithSourceMap { scopes: Arc::new(scopes), source_map: Arc::new(source_map) };
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 7c603bbd3..c19450f39 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -56,7 +56,7 @@ pub use self::{
     name::Name,
     source_id::{AstIdMap, ErasedFileAstId},
     ids::{HirFileId, MacroDefId, MacroCallId, MacroCallLoc, HirInterner},
-    nameres::{PerNs, Namespace},
+    nameres::{PerNs, Namespace, ImportId, ImportSource},
     ty::{Ty, ApplicationTy, TypeCtor, Substs, display::HirDisplay},
     impl_block::{ImplBlock, ImplItem},
     docs::{Docs, Documentation},
@@ -67,6 +67,7 @@ pub use self::{
 
 pub use self::code_model_api::{
     Crate, CrateDependency,
+    DefWithBody,
     Module, ModuleDef, ModuleSource,
     Struct, Enum, EnumVariant,
     Function, FnSignature,
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 8adc6d368..4ae04514a 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -71,9 +71,12 @@ use crate::{
     AstId,
 };
 
-pub(crate) use self::raw::{RawItems, ImportId, ImportSourceMap};
+pub(crate) use self::raw::{RawItems, ImportSourceMap};
 
-pub use self::per_ns::{PerNs, Namespace};
+pub use self::{
+    per_ns::{PerNs, Namespace},
+    raw::{ImportId, ImportSource},
+};
 
 /// Contans all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 0936229ac..b7416ede6 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -31,21 +31,43 @@ pub struct RawItems {
 
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, AstPtr<ast::PathSegment>>,
+    map: ArenaMap<ImportId, ImportSourcePtr>,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum ImportSourcePtr {
+    UseTree(AstPtr<ast::UseTree>),
+    ExternCrate(AstPtr<ast::ExternCrateItem>),
+}
+
+impl ImportSourcePtr {
+    fn to_node(self, file: &SourceFile) -> ImportSource {
+        match self {
+            ImportSourcePtr::UseTree(ptr) => ImportSource::UseTree(ptr.to_node(file).to_owned()),
+            ImportSourcePtr::ExternCrate(ptr) => {
+                ImportSource::ExternCrate(ptr.to_node(file).to_owned())
+            }
+        }
+    }
+}
+
+pub enum ImportSource {
+    UseTree(TreeArc<ast::UseTree>),
+    ExternCrate(TreeArc<ast::ExternCrateItem>),
 }
 
 impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
-        self.map.insert(import, AstPtr::new(segment))
+    fn insert(&mut self, import: ImportId, ptr: ImportSourcePtr) {
+        self.map.insert(import, ptr)
     }
 
-    pub(crate) fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
+    pub(crate) fn get(&self, source: &ModuleSource, import: ImportId) -> ImportSource {
         let file = match source {
             ModuleSource::SourceFile(file) => &*file,
             ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
         };
 
-        self.map[import].to_node(file).to_owned()
+        self.map[import].to_node(file)
     }
 }
 
@@ -256,18 +278,14 @@ impl RawItemsCollector {
     fn add_use_item(&mut self, current_module: Option<Module>, use_item: &ast::UseItem) {
         let is_prelude = use_item.has_atom_attr("prelude_import");
 
-        Path::expand_use_item(use_item, |path, segment, alias| {
-            let import = self.raw_items.imports.alloc(ImportData {
-                path,
-                alias,
-                is_glob: segment.is_none(),
-                is_prelude,
-                is_extern_crate: false,
-            });
-            if let Some(segment) = segment {
-                self.source_map.insert(import, segment)
-            }
-            self.push_item(current_module, RawItem::Import(import))
+        Path::expand_use_item(use_item, |path, use_tree, is_glob, alias| {
+            let import_data =
+                ImportData { path, alias, is_glob, is_prelude, is_extern_crate: false };
+            self.push_import(
+                current_module,
+                import_data,
+                ImportSourcePtr::UseTree(AstPtr::new(use_tree)),
+            );
         })
     }
 
@@ -279,14 +297,18 @@ impl RawItemsCollector {
         if let Some(name_ref) = extern_crate.name_ref() {
             let path = Path::from_name_ref(name_ref);
             let alias = extern_crate.alias().and_then(|a| a.name()).map(AsName::as_name);
-            let import = self.raw_items.imports.alloc(ImportData {
+            let import_data = ImportData {
                 path,
                 alias,
                 is_glob: false,
                 is_prelude: false,
                 is_extern_crate: true,
-            });
-            self.push_item(current_module, RawItem::Import(import))
+            };
+            self.push_import(
+                current_module,
+                import_data,
+                ImportSourcePtr::ExternCrate(AstPtr::new(extern_crate)),
+            );
         }
     }
 
@@ -303,6 +325,17 @@ impl RawItemsCollector {
         self.push_item(current_module, RawItem::Macro(m));
     }
 
+    fn push_import(
+        &mut self,
+        current_module: Option<Module>,
+        data: ImportData,
+        source: ImportSourcePtr,
+    ) {
+        let import = self.raw_items.imports.alloc(data);
+        self.source_map.insert(import, source);
+        self.push_item(current_module, RawItem::Import(import))
+    }
+
     fn push_item(&mut self, current_module: Option<Module>, item: RawItem) {
         match current_module {
             Some(module) => match &mut self.raw_items.modules[module] {
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 6cc8104f4..5449cddfd 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -46,7 +46,7 @@ impl Path {
     /// Calls `cb` with all paths, represented by this use item.
     pub fn expand_use_item<'a>(
         item: &'a ast::UseItem,
-        mut cb: impl FnMut(Path, Option<&'a ast::PathSegment>, Option<Name>),
+        mut cb: impl FnMut(Path, &'a ast::UseTree, bool, Option<Name>),
     ) {
         if let Some(tree) = item.use_tree() {
             expand_use_tree(None, tree, &mut cb);
@@ -156,7 +156,7 @@ impl From<Name> for Path {
 fn expand_use_tree<'a>(
     prefix: Option<Path>,
     tree: &'a ast::UseTree,
-    cb: &mut impl FnMut(Path, Option<&'a ast::PathSegment>, Option<Name>),
+    cb: &mut impl FnMut(Path, &'a ast::UseTree, bool, Option<Name>),
 ) {
     if let Some(use_tree_list) = tree.use_tree_list() {
         let prefix = match tree.path() {
@@ -181,18 +181,15 @@ fn expand_use_tree<'a>(
                 if let Some(segment) = ast_path.segment() {
                     if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
                         if let Some(prefix) = prefix {
-                            cb(prefix, Some(segment), alias);
+                            cb(prefix, tree, false, alias);
                             return;
                         }
                     }
                 }
             }
             if let Some(path) = convert_path(prefix, ast_path) {
-                if tree.has_star() {
-                    cb(path, None, alias)
-                } else if let Some(segment) = ast_path.segment() {
-                    cb(path, Some(segment), alias)
-                };
+                let is_glob = tree.has_star();
+                cb(path, tree, is_glob, alias)
             }
             // FIXME: report errors somewhere
             // We get here if we do
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 9dae4c3d1..182ed4c91 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -9,11 +9,11 @@ use ra_db::{FileId, FilePosition};
 use ra_syntax::{
     SyntaxNode,
     ast::{self, AstNode, NameOwner},
-    algo::{find_node_at_offset, find_leaf_at_offset},
+    algo::{find_node_at_offset, find_token_at_offset},
 };
 
 use crate::{
-    HirDatabase, Function, Struct, Enum,
+    HirDatabase, Function, Struct, Enum,Const,Static,
     AsName, Module, HirFileId, Crate, Trait, Resolver,
     ids::LocationCtx,
     expr, AstId
@@ -87,6 +87,27 @@ fn module_from_source(
     )
 }
 
+pub fn const_from_source(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    const_def: &ast::ConstDef,
+) -> Option<Const> {
+    let module = module_from_child_node(db, file_id, const_def.syntax())?;
+    let res = const_from_module(db, module, const_def);
+    Some(res)
+}
+
+pub fn const_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    const_def: &ast::ConstDef,
+) -> Const {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Const { id: ctx.to_def(const_def) }
+}
+
 pub fn function_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Function> {
     let file = db.parse(position.file_id);
     let fn_def = find_node_at_offset::<ast::FnDef>(file.syntax(), position.offset)?;
@@ -134,6 +155,27 @@ pub fn struct_from_module(
     Struct { id: ctx.to_def(struct_def) }
 }
 
+pub fn static_from_source(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    static_def: &ast::StaticDef,
+) -> Option<Static> {
+    let module = module_from_child_node(db, file_id, static_def.syntax())?;
+    let res = static_from_module(db, module, static_def);
+    Some(res)
+}
+
+pub fn static_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    static_def: &ast::StaticDef,
+) -> Static {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Static { id: ctx.to_def(static_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();
@@ -155,9 +197,9 @@ pub fn trait_from_module(
 pub fn resolver_for_position(db: &impl HirDatabase, position: FilePosition) -> Resolver {
     let file_id = position.file_id;
     let file = db.parse(file_id);
-    find_leaf_at_offset(file.syntax(), position.offset)
-        .find_map(|node| {
-            node.ancestors().find_map(|node| {
+    find_token_at_offset(file.syntax(), position.offset)
+        .find_map(|token| {
+            token.parent().ancestors().find_map(|node| {
                 if ast::Expr::cast(node).is_some() || ast::Block::cast(node).is_some() {
                     if let Some(func) = function_from_child_node(db, file_id, node) {
                         let scopes = func.scopes(db);
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 573115321..887153484 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -27,8 +27,9 @@ use test_utils::tested_by;
 
 use crate::{
     Function, StructField, Path, Name,
-    FnSignature, AdtDef,
+    FnSignature, AdtDef,ConstSignature,
     HirDatabase,
+    DefWithBody,
     ImplItem,
     type_ref::{TypeRef, Mutability},
     expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self},
@@ -43,14 +44,17 @@ use crate::{
 use super::{Ty, TypableDef, Substs, primitive, op, FnSig, ApplicationTy, TypeCtor};
 
 /// The entry point of type inference.
-pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
+pub fn infer(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
     db.check_canceled();
-    let body = func.body(db);
-    let resolver = func.resolver(db);
+    let body = def.body(db);
+    let resolver = def.resolver(db);
     let mut ctx = InferenceContext::new(db, body, resolver);
 
-    let signature = func.signature(db);
-    ctx.collect_fn_signature(&signature);
+    match def {
+        DefWithBody::Const(ref c) => ctx.collect_const_signature(&c.signature(db)),
+        DefWithBody::Function(ref f) => ctx.collect_fn_signature(&f.signature(db)),
+        DefWithBody::Static(ref s) => ctx.collect_const_signature(&s.signature(db)),
+    }
 
     ctx.infer_body();
 
@@ -1142,6 +1146,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         ty
     }
 
+    fn collect_const_signature(&mut self, signature: &ConstSignature) {
+        self.return_ty = self.make_ty(signature.type_ref());
+    }
+
     fn collect_fn_signature(&mut self, signature: &FnSignature) {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
         for (type_ref, pat) in signature.params().iter().zip(body.params()) {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 655f3c522..0b7c841df 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -11,6 +11,8 @@ use crate::{
     source_binder,
     mock::MockDatabase,
     ty::display::HirDisplay,
+    ty::InferenceResult,
+    expr::BodySourceMap
 };
 
 // These tests compare the inference results for all expressions in a file
@@ -1267,6 +1269,9 @@ fn test() {
 }
 "#),
         @r###"
+[52; 53) '1': u32
+[103; 104) '2': u32
+[211; 212) '5': u32
 [227; 305) '{     ...:ID; }': ()
 [237; 238) 'x': u32
 [241; 252) 'Struct::FOO': u32
@@ -1855,6 +1860,9 @@ fn test() {
 }
 "#),
         @r###"
+[49; 50) '0': u32
+[80; 83) '101': u32
+[126; 128) '99': u32
 [95; 213) '{     ...NST; }': ()
 [138; 139) 'x': {unknown}
 [142; 153) 'LOCAL_CONST': {unknown}
@@ -1881,6 +1889,10 @@ fn test() {
 }
 "#),
         @r###"
+[29; 32) '101': u32
+[70; 73) '101': u32
+[118; 120) '99': u32
+[161; 163) '99': u32
 [85; 280) '{     ...MUT; }': ()
 [173; 174) 'x': {unknown}
 [177; 189) 'LOCAL_STATIC': {unknown}
@@ -2212,6 +2224,24 @@ fn test<T: Iterable<Item=u32>>() {
     );
 }
 
+#[test]
+fn infer_const_body() {
+    assert_snapshot_matches!(
+        infer(r#"
+const A: u32 = 1 + 1;
+static B: u64 = { let x = 1; x };
+"#),
+        @r###"
+[16; 17) '1': u32
+[16; 21) '1 + 1': u32
+[20; 21) '1': u32
+[39; 55) '{ let ...1; x }': u64
+[45; 46) 'x': u64
+[49; 50) '1': u64
+[52; 53) 'x': u64"###
+    );
+}
+
 fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
     let func = source_binder::function_from_position(db, pos).unwrap();
     let body_source_map = func.body_source_map(db);
@@ -2228,11 +2258,11 @@ fn infer(content: &str) -> String {
     let source_file = db.parse(file_id);
     let mut acc = String::new();
     acc.push_str("\n");
-    for fn_def in source_file.syntax().descendants().filter_map(ast::FnDef::cast) {
-        let func = source_binder::function_from_source(&db, file_id, fn_def).unwrap();
-        let inference_result = func.infer(&db);
-        let body_source_map = func.body_source_map(&db);
+
+    let mut infer_def = |inference_result: Arc<InferenceResult>,
+                         body_source_map: Arc<BodySourceMap>| {
         let mut types = Vec::new();
+
         for (pat, ty) in inference_result.type_of_pat.iter() {
             let syntax_ptr = match body_source_map.pat_syntax(pat) {
                 Some(sp) => sp,
@@ -2240,6 +2270,7 @@ fn infer(content: &str) -> String {
             };
             types.push((syntax_ptr, ty));
         }
+
         for (expr, ty) in inference_result.type_of_expr.iter() {
             let syntax_ptr = match body_source_map.expr_syntax(expr) {
                 Some(sp) => sp,
@@ -2251,16 +2282,36 @@ fn infer(content: &str) -> String {
         types.sort_by_key(|(ptr, _)| (ptr.range().start(), ptr.range().end()));
         for (syntax_ptr, ty) in &types {
             let node = syntax_ptr.to_node(&source_file);
-            write!(
-                acc,
-                "{} '{}': {}\n",
-                syntax_ptr.range(),
-                ellipsize(node.text().to_string().replace("\n", " "), 15),
-                ty.display(&db)
-            )
-            .unwrap();
+            let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node) {
+                (self_param.self_kw_token().range(), "self".to_string())
+            } else {
+                (syntax_ptr.range(), node.text().to_string().replace("\n", " "))
+            };
+            write!(acc, "{} '{}': {}\n", range, ellipsize(text, 15), ty.display(&db)).unwrap();
         }
+    };
+
+    for const_def in source_file.syntax().descendants().filter_map(ast::ConstDef::cast) {
+        let konst = source_binder::const_from_source(&db, file_id, const_def).unwrap();
+        let inference_result = konst.infer(&db);
+        let body_source_map = konst.body_source_map(&db);
+        infer_def(inference_result, body_source_map)
     }
+
+    for static_def in source_file.syntax().descendants().filter_map(ast::StaticDef::cast) {
+        let static_ = source_binder::static_from_source(&db, file_id, static_def).unwrap();
+        let inference_result = static_.infer(&db);
+        let body_source_map = static_.body_source_map(&db);
+        infer_def(inference_result, body_source_map)
+    }
+
+    for fn_def in source_file.syntax().descendants().filter_map(ast::FnDef::cast) {
+        let func = source_binder::function_from_source(&db, file_id, fn_def).unwrap();
+        let inference_result = func.infer(&db);
+        let body_source_map = func.body_source_map(&db);
+        infer_def(inference_result, body_source_map)
+    }
+
     acc.truncate(acc.trim_end().len());
     acc
 }