16 files changed, 178 insertions, 89 deletions

diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 3d802ade4..57a4b155b 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -12,7 +12,6 @@ rustc-hash = "1.0"
 parking_lot = "0.7.0"
 ena = "0.11"
 join_to_string = "0.1.3"
-salsa = "0.10.0-alpha3"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_arena = { path = "../ra_arena" }
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index ec6a10353..22bbad964 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 
 use crate::{
     Name, AsName, Struct, Enum, EnumVariant, Crate,
-    HirDatabase, HirFileId,
+    HirDatabase, HirFileId, StructField, FieldSource,
     type_ref::TypeRef,
 };
 
@@ -150,7 +150,7 @@ impl VariantData {
 impl VariantData {
     fn new(flavor: StructFlavor) -> Self {
         let inner = match flavor {
-            StructFlavor::Tuple(fl) => {
+            ast::StructFlavor::Tuple(fl) => {
                 let fields = fl
                     .fields()
                     .enumerate()
@@ -161,7 +161,7 @@ impl VariantData {
                     .collect();
                 VariantDataInner::Tuple(fields)
             }
-            StructFlavor::Named(fl) => {
+            ast::StructFlavor::Named(fl) => {
                 let fields = fl
                     .fields()
                     .map(|fd| StructFieldData {
@@ -171,8 +171,70 @@ impl VariantData {
                     .collect();
                 VariantDataInner::Struct(fields)
             }
-            StructFlavor::Unit => VariantDataInner::Unit,
+            ast::StructFlavor::Unit => VariantDataInner::Unit,
         };
         VariantData(inner)
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum VariantDef {
+    Struct(Struct),
+    EnumVariant(EnumVariant),
+}
+impl_froms!(VariantDef: Struct, EnumVariant);
+
+impl VariantDef {
+    pub(crate) fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
+        match self {
+            VariantDef::Struct(it) => it.field(db, name),
+            VariantDef::EnumVariant(it) => it.field(db, name),
+        }
+    }
+    pub(crate) fn variant_data(self, db: &impl HirDatabase) -> Arc<VariantData> {
+        match self {
+            VariantDef::Struct(it) => it.variant_data(db),
+            VariantDef::EnumVariant(it) => it.variant_data(db),
+        }
+    }
+}
+
+impl StructField {
+    pub(crate) fn source_impl(&self, db: &impl HirDatabase) -> (HirFileId, FieldSource) {
+        let var_data = self.parent.variant_data(db);
+        let fields = var_data.fields().unwrap();
+        let ss;
+        let es;
+        let (file_id, struct_flavor) = match self.parent {
+            VariantDef::Struct(s) => {
+                let (file_id, source) = s.source(db);
+                ss = source;
+                (file_id, ss.flavor())
+            }
+            VariantDef::EnumVariant(e) => {
+                let (file_id, source) = e.source(db);
+                es = source;
+                (file_id, es.flavor())
+            }
+        };
+
+        let field_sources = match struct_flavor {
+            ast::StructFlavor::Tuple(fl) => fl
+                .fields()
+                .map(|it| FieldSource::Pos(it.to_owned()))
+                .collect(),
+            ast::StructFlavor::Named(fl) => fl
+                .fields()
+                .map(|it| FieldSource::Named(it.to_owned()))
+                .collect(),
+            ast::StructFlavor::Unit => Vec::new(),
+        };
+        let field = field_sources
+            .into_iter()
+            .zip(fields.iter())
+            .find(|(_syntax, (id, _))| *id == self.id)
+            .unwrap()
+            .0;
+        (file_id, field)
+    }
+}
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 118562984..191104890 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -10,8 +10,8 @@ use crate::{
     nameres::{ModuleScope, lower::ImportId},
     db::HirDatabase,
     expr::BodySyntaxMapping,
-    ty::{InferenceResult, VariantDef},
-    adt::{EnumVariantId, StructFieldId},
+    ty::InferenceResult,
+    adt::{EnumVariantId, StructFieldId, VariantDef},
     generics::GenericParams,
     docs::{Documentation, Docs, docs_from_ast},
     module_tree::ModuleId,
@@ -177,12 +177,25 @@ impl Module {
     }
 }
 
+impl Docs for Module {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
+        self.declaration_source(db)
+            .and_then(|it| docs_from_ast(&*it.1))
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StructField {
-    parent: VariantDef,
+    pub(crate) parent: VariantDef,
     pub(crate) id: StructFieldId,
 }
 
+#[derive(Debug)]
+pub enum FieldSource {
+    Named(TreeArc<ast::NamedFieldDef>),
+    Pos(TreeArc<ast::PosFieldDef>),
+}
+
 impl StructField {
     pub fn name(&self, db: &impl HirDatabase) -> Name {
         self.parent.variant_data(db).fields().unwrap()[self.id]
@@ -190,6 +203,10 @@ impl StructField {
             .clone()
     }
 
+    pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, FieldSource) {
+        self.source_impl(db)
+    }
+
     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
         db.type_for_field(*self)
     }
@@ -199,6 +216,15 @@ impl StructField {
     }
 }
 
+impl Docs for StructField {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
+        match self.source(db).1 {
+            FieldSource::Named(named) => docs_from_ast(&*named),
+            FieldSource::Pos(..) => return None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Struct {
     pub(crate) id: StructId,
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 3c82262a2..5df4bd4a1 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use ra_syntax::{SyntaxNode, TreeArc, SourceFile};
-use ra_db::{SyntaxDatabase, CrateId, salsa};
+use ra_db::{SourceDatabase, CrateId, salsa};
 
 use crate::{
     MacroCallId, HirFileId,
@@ -18,10 +18,10 @@ use crate::{
     generics::{GenericParams, GenericDef},
 };
 
-#[salsa::query_group]
-pub trait HirDatabase: SyntaxDatabase + AsRef<HirInterner> {
-    #[salsa::invoke(HirFileId::hir_source_file)]
-    fn hir_source_file(&self, file_id: HirFileId) -> TreeArc<SourceFile>;
+#[salsa::query_group(HirDatabaseStorage)]
+pub trait HirDatabase: SourceDatabase + AsRef<HirInterner> {
+    #[salsa::invoke(HirFileId::hir_parse)]
+    fn hir_parse(&self, file_id: HirFileId) -> TreeArc<SourceFile>;
 
     #[salsa::invoke(crate::macros::expand_macro_invocation)]
     fn expand_macro_invocation(&self, invoc: MacroCallId) -> Option<Arc<MacroExpansion>>;
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 5272656ec..7dd4b540e 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -86,12 +86,9 @@ impl HirFileId {
         }
     }
 
-    pub(crate) fn hir_source_file(
-        db: &impl HirDatabase,
-        file_id: HirFileId,
-    ) -> TreeArc<SourceFile> {
+    pub(crate) fn hir_parse(db: &impl HirDatabase, file_id: HirFileId) -> TreeArc<SourceFile> {
         match file_id.0 {
-            HirFileIdRepr::File(file_id) => db.source_file(file_id),
+            HirFileIdRepr::File(file_id) => db.parse(file_id),
             HirFileIdRepr::Macro(m) => {
                 if let Some(exp) = db.expand_macro_invocation(m) {
                     return exp.file();
@@ -370,7 +367,7 @@ impl SourceFileItems {
             self.arena.iter().map(|(_id, i)| i).collect::<Vec<_>>(),
         );
     }
-    pub fn id_of_source_file(&self) -> SourceFileItemId {
+    pub fn id_of_parse(&self) -> SourceFileItemId {
         let (id, _syntax) = self.arena.iter().next().unwrap();
         id
     }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 596f9c38c..eaf8565ee 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -68,7 +68,7 @@ pub use self::code_model_api::{
     Module, ModuleDef, ModuleSource, Problem,
     Struct, Enum, EnumVariant,
     Function, FnSignature, ScopeEntryWithSyntax,
-    StructField,
+    StructField, FieldSource,
     Static, Const,
     Trait, Type,
 };
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 36b174cd6..7da15eca0 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -2,7 +2,7 @@ use std::{sync::Arc, panic};
 
 use parking_lot::Mutex;
 use ra_db::{
-    BaseDatabase, FilePosition, FileId, CrateGraph, SourceRoot, SourceRootId, FilesDatabase,
+    CheckCanceled, FilePosition, FileId, CrateGraph, SourceRoot, SourceRootId, SourceDatabase, salsa,
 };
 use relative_path::RelativePathBuf;
 use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
@@ -11,7 +11,7 @@ use crate::{db, HirInterner};
 
 pub const WORKSPACE: SourceRootId = SourceRootId(0);
 
-#[salsa::database(ra_db::FilesDatabase, ra_db::SyntaxDatabase, db::HirDatabase)]
+#[salsa::database(ra_db::SourceDatabaseStorage, db::HirDatabaseStorage)]
 #[derive(Debug)]
 pub(crate) struct MockDatabase {
     events: Mutex<Option<Vec<salsa::Event<MockDatabase>>>>,
@@ -140,8 +140,6 @@ impl Default for MockDatabase {
             file_counter: 0,
         };
         db.set_crate_graph(Default::default());
-        db.set_local_roots(Default::default());
-        db.set_library_roots(Default::default());
         db
     }
 }
@@ -157,7 +155,7 @@ impl salsa::ParallelDatabase for MockDatabase {
     }
 }
 
-impl BaseDatabase for MockDatabase {}
+impl CheckCanceled for MockDatabase {}
 
 impl AsRef<HirInterner> for MockDatabase {
     fn as_ref(&self) -> &HirInterner {
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index c00834c4c..d5ad9decb 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use rustc_hash::{FxHashMap, FxHashSet};
 use arrayvec::ArrayVec;
 use relative_path::RelativePathBuf;
 use ra_db::{FileId, SourceRoot, CrateId};
@@ -147,28 +146,21 @@ impl ModuleTree {
         let file_id = crate_graph.crate_root(crate_id);
         let source_root_id = db.file_source_root(file_id);
 
-        let mut roots = FxHashMap::default();
-        let mut visited = FxHashSet::default();
-
         let source_root = db.source_root(source_root_id);
         let source = SourceItemId {
             file_id: file_id.into(),
             item_id: None,
         };
-        let module_id = self.init_subtree(db, &source_root, &mut visited, &mut roots, None, source);
-        roots.insert(file_id, module_id);
+        self.init_subtree(db, &source_root, None, source);
     }
 
     fn init_subtree(
         &mut self,
         db: &impl HirDatabase,
         source_root: &SourceRoot,
-        visited: &mut FxHashSet<SourceItemId>,
-        roots: &mut FxHashMap<FileId, ModuleId>,
         parent: Option<LinkId>,
         source: SourceItemId,
     ) -> ModuleId {
-        visited.insert(source);
         let id = self.alloc_mod(ModuleData {
             source,
             parent,
@@ -187,28 +179,21 @@ impl ModuleTree {
                 let (points_to, problem) = resolve_submodule(db, source.file_id, &sub.name);
                 let points_to = points_to
                     .into_iter()
-                    .map(|file_id| match roots.remove(&file_id) {
-                        Some(module_id) => {
-                            self.mods[module_id].parent = Some(link);
-                            module_id
-                        }
-                        None => self.init_subtree(
+                    .map(|file_id| {
+                        self.init_subtree(
                             db,
                             source_root,
-                            visited,
-                            roots,
                             Some(link),
                             SourceItemId {
                                 file_id: file_id.into(),
                                 item_id: None,
                             },
-                        ),
+                        )
                     })
                     .collect::<Vec<_>>();
                 (points_to, problem)
             } else {
-                let points_to =
-                    self.init_subtree(db, source_root, visited, roots, Some(link), sub.source);
+                let points_to = self.init_subtree(db, source_root, Some(link), sub.source);
                 (vec![points_to], None)
             };
 
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 028c1882f..5193900e0 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -190,7 +190,12 @@ where
             self.populate_module(module_id, Arc::clone(items));
         }
 
+        let mut iter = 0;
         loop {
+            iter += 1;
+            if iter > 1000 {
+                panic!("failed to reach fixedpoint after 1000 iters")
+            }
             let processed_imports_count = self.processed_imports.len();
             for &module_id in self.input.keys() {
                 self.db.check_canceled();
diff --git a/crates/ra_hir/src/nameres/lower.rs b/crates/ra_hir/src/nameres/lower.rs
index b4fe99ea7..1d77548f3 100644
--- a/crates/ra_hir/src/nameres/lower.rs
+++ b/crates/ra_hir/src/nameres/lower.rs
@@ -129,7 +129,7 @@ impl LoweredModule {
                     let id = loc.id(db);
                     let file_id = HirFileId::from(id);
                     //FIXME: expand recursively
-                    for item in db.hir_source_file(file_id).items() {
+                    for item in db.hir_parse(file_id).items() {
                         self.add_def_id(source_map, db, module, file_id, item);
                     }
                 }
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 24936976c..e72781f51 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use ra_db::{CrateGraph, SourceRootId, FilesDatabase};
+use ra_db::{CrateGraph, SourceRootId, SourceDatabase};
 use relative_path::RelativePath;
 use test_utils::{assert_eq_text, covers};
 
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index cf8c7e435..61c93a964 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -23,7 +23,7 @@ pub(super) fn fn_scopes(db: &impl HirDatabase, func: Function) -> Arc<FnScopes>
 }
 
 pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
-    let source_file = db.hir_source_file(file_id);
+    let source_file = db.hir_parse(file_id);
     let res = SourceFileItems::new(file_id, &source_file);
     Arc::new(res)
 }
@@ -34,10 +34,7 @@ pub(super) fn file_item(
 ) -> TreeArc<SyntaxNode> {
     match source_item_id.item_id {
         Some(id) => db.file_items(source_item_id.file_id)[id].to_owned(),
-        None => db
-            .hir_source_file(source_item_id.file_id)
-            .syntax()
-            .to_owned(),
+        None => db.hir_parse(source_item_id.file_id).syntax().to_owned(),
     }
 }
 
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index dbe040805..c0b3f1cd4 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -43,7 +43,7 @@ pub fn module_from_declaration(
 
 /// Locates the module by position in the source code.
 pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
-    let file = db.source_file(position.file_id);
+    let file = db.parse(position.file_id);
     match find_node_at_offset::<ast::Module>(file.syntax(), position.offset) {
         Some(m) if !m.has_semi() => module_from_inline(db, position.file_id.into(), m),
         _ => module_from_file_id(db, position.file_id.into()),
@@ -95,7 +95,7 @@ fn module_from_source(db: &impl HirDatabase, source: SourceItemId) -> Option<Mod
 }
 
 pub fn function_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Function> {
-    let file = db.source_file(position.file_id);
+    let file = db.parse(position.file_id);
     let fn_def = find_node_at_offset::<ast::FnDef>(file.syntax(), position.offset)?;
     function_from_source(db, position.file_id, fn_def)
 }
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index c57e222dd..179ebddee 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -38,7 +38,7 @@ use crate::{
     expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat},
     generics::GenericParams,
     path::GenericArg,
-    adt::VariantData,
+    adt::VariantDef,
 };
 
 /// The ID of a type variable.
@@ -696,28 +696,6 @@ pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef) -> Ty {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum VariantDef {
-    Struct(Struct),
-    EnumVariant(EnumVariant),
-}
-impl_froms!(VariantDef: Struct, EnumVariant);
-
-impl VariantDef {
-    pub(crate) fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
-        match self {
-            VariantDef::Struct(it) => it.field(db, name),
-            VariantDef::EnumVariant(it) => it.field(db, name),
-        }
-    }
-    pub(crate) fn variant_data(self, db: &impl HirDatabase) -> Arc<VariantData> {
-        match self {
-            VariantDef::Struct(it) => it.variant_data(db),
-            VariantDef::EnumVariant(it) => it.variant_data(db),
-        }
-    }
-}
-
 pub(super) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
     let parent_def = field.parent_def(db);
     let (generics, module) = match parent_def {
@@ -732,8 +710,10 @@ pub(super) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct InferenceResult {
-    /// For each method call expr, record the function it resolved to.
+    /// For each method call expr, records the function it resolves to.
     method_resolutions: FxHashMap<ExprId, Function>,
+    /// For each field access expr, records the field it resolves to.
+    field_resolutions: FxHashMap<ExprId, StructField>,
     type_of_expr: ArenaMap<ExprId, Ty>,
     type_of_pat: ArenaMap<PatId, Ty>,
 }
@@ -742,6 +722,9 @@ impl InferenceResult {
     pub fn method_resolution(&self, expr: ExprId) -> Option<Function> {
         self.method_resolutions.get(&expr).map(|it| *it)
     }
+    pub fn field_resolution(&self, expr: ExprId) -> Option<StructField> {
+        self.field_resolutions.get(&expr).map(|it| *it)
+    }
 }
 
 impl Index<ExprId> for InferenceResult {
@@ -770,6 +753,7 @@ struct InferenceContext<'a, D: HirDatabase> {
     impl_block: Option<ImplBlock>,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
     method_resolutions: FxHashMap<ExprId, Function>,
+    field_resolutions: FxHashMap<ExprId, StructField>,
     type_of_expr: ArenaMap<ExprId, Ty>,
     type_of_pat: ArenaMap<PatId, Ty>,
     /// The return type of the function being inferred.
@@ -806,7 +790,10 @@ fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
         | BinaryOp::BitwiseAnd
         | BinaryOp::BitwiseOr
         | BinaryOp::BitwiseXor => match rhs_ty {
-            Ty::Int(..) | Ty::Float(..) => rhs_ty,
+            Ty::Int(..)
+            | Ty::Float(..)
+            | Ty::Infer(InferTy::IntVar(..))
+            | Ty::Infer(InferTy::FloatVar(..)) => rhs_ty,
             _ => Ty::Unknown,
         },
         BinaryOp::RangeRightOpen | BinaryOp::RangeRightClosed => Ty::Unknown,
@@ -861,6 +848,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     ) -> Self {
         InferenceContext {
             method_resolutions: FxHashMap::default(),
+            field_resolutions: FxHashMap::default(),
             type_of_expr: ArenaMap::default(),
             type_of_pat: ArenaMap::default(),
             var_unification_table: InPlaceUnificationTable::new(),
@@ -886,6 +874,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         }
         InferenceResult {
             method_resolutions: mem::replace(&mut self.method_resolutions, Default::default()),
+            field_resolutions: mem::replace(&mut self.field_resolutions, Default::default()),
             type_of_expr: expr_types,
             type_of_pat: pat_types,
         }
@@ -899,6 +888,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.method_resolutions.insert(expr, func);
     }
 
+    fn write_field_resolution(&mut self, expr: ExprId, field: StructField) {
+        self.field_resolutions.insert(expr, field);
+    }
+
     fn write_pat_ty(&mut self, pat: PatId, ty: Ty) {
         self.type_of_pat.insert(pat, ty);
     }
@@ -1251,9 +1244,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         ty
     }
 
-    fn infer_expr(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
+    fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
-        let ty = match &body[expr] {
+        let ty = match &body[tgt_expr] {
             Expr::Missing => Ty::Unknown,
             Expr::If {
                 condition,
@@ -1344,7 +1337,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let resolved = receiver_ty.clone().lookup_method(self.db, method_name);
                 let method_ty = match resolved {
                     Some(func) => {
-                        self.write_method_resolution(expr, func);
+                        self.write_method_resolution(tgt_expr, func);
                         self.db.type_for_def(func.into())
                     }
                     None => Ty::Unknown,
@@ -1389,7 +1382,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
                 expected.ty
             }
-            Expr::Path(p) => self.infer_path_expr(expr, p).unwrap_or(Ty::Unknown),
+            Expr::Path(p) => self.infer_path_expr(tgt_expr, p).unwrap_or(Ty::Unknown),
             Expr::Continue => Ty::Never,
             Expr::Break { expr } => {
                 if let Some(expr) = expr {
@@ -1436,9 +1429,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             def_id: AdtDef::Struct(s),
                             ref substs,
                             ..
-                        } => s
-                            .field(self.db, name)
-                            .map(|field| field.ty(self.db).subst(substs)),
+                        } => s.field(self.db, name).map(|field| {
+                            self.write_field_resolution(tgt_expr, field);
+                            field.ty(self.db).subst(substs)
+                        }),
                         _ => None,
                     })
                     .unwrap_or(Ty::Unknown);
@@ -1545,7 +1539,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         let ty = self.insert_type_vars_shallow(ty);
         self.unify(&ty, &expected.ty);
         let ty = self.resolve_ty_as_possible(ty);
-        self.write_expr_ty(expr, ty.clone());
+        self.write_expr_ty(tgt_expr, ty.clone());
         ty
     }
 
diff --git a/crates/ra_hir/src/ty/snapshots/tests__bug_651.snap b/crates/ra_hir/src/ty/snapshots/tests__bug_651.snap
new file mode 100644
index 000000000..d23d3f139
--- /dev/null
+++ b/crates/ra_hir/src/ty/snapshots/tests__bug_651.snap
@@ -0,0 +1,13 @@
+---
+created: "2019-01-25T20:31:47.275112244+00:00"
+creator: [email protected]
+expression: "&result"
+source: crates/ra_hir/src/ty/tests.rs
+---
+[11; 41) '{     ...+ y; }': ()
+[21; 22) 'y': i32
+[25; 27) '92': i32
+[33; 34) '1': i32
+[33; 38) '1 + y': i32
+[37; 38) 'y': i32
+
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 92c74cf00..e0b0689f8 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use std::fmt::Write;
 
-use ra_db::{SyntaxDatabase, salsa::Database};
+use ra_db::{SourceDatabase, salsa::Database};
 use ra_syntax::ast::{self, AstNode};
 
 use crate::{
@@ -532,9 +532,22 @@ fn test() {
     );
 }
 
+#[test]
+fn bug_651() {
+    check_inference(
+        "bug_651",
+        r#"
+fn quux() {
+    let y = 92;
+    1 + y;
+}
+"#,
+    );
+}
+
 fn infer(content: &str) -> String {
     let (db, _, file_id) = MockDatabase::with_single_file(content);
-    let source_file = db.source_file(file_id);
+    let source_file = db.parse(file_id);
     let mut acc = String::new();
     for fn_def in source_file
         .syntax()