16 files changed, 166 insertions, 227 deletions
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index b3e2ff1c2..3f44a50c4 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -6,7 +6,6 @@ use std::sync::Arc;
 use hir_def::{
    adt::VariantData,
-    body::scope::ExprScopes,
    builtin_type::BuiltinType,
    docs::Documentation,
    per_ns::PerNs,
@@ -28,7 +27,7 @@ use crate::{
    db::{DefDatabase, HirDatabase},
    expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
    ty::{InferenceResult, Namespace, TraitRef},
-    Either, HasSource, Name, Source, Ty,
+    Either, Name, Source, Ty,
 };
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -62,7 +61,7 @@ impl Crate {
    }
    pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> {
-        let module_id = db.crate_def_map(self.crate_id).root();
+        let module_id = db.crate_def_map(self.crate_id).root;
        Some(Module::new(self, module_id))
    }
@@ -195,7 +194,7 @@ impl Module {
    /// in the module tree of any target in `Cargo.toml`.
    pub fn crate_root(self, db: &impl DefDatabase) -> Module {
        let def_map = db.crate_def_map(self.id.krate);
-        self.with_module_id(def_map.root())
+        self.with_module_id(def_map.root)
    }
    /// Finds a child module with the specified name.
@@ -302,11 +301,11 @@ pub enum FieldSource {
 impl StructField {
    pub fn name(&self, db: &impl HirDatabase) -> Name {
-        self.parent.variant_data(db).fields().unwrap()[self.id].name.clone()
+        self.parent.variant_data(db).fields()[self.id].name.clone()
    }
    pub fn ty(&self, db: &impl HirDatabase) -> Ty {
-        db.type_for_field(*self)
+        db.field_types(self.parent.into())[self.id].clone()
    }
    pub fn parent_def(&self, _db: &impl HirDatabase) -> VariantDef {
@@ -336,8 +335,7 @@ impl Struct {
        db.struct_data(self.id.into())
            .variant_data
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .map(|(id, _)| StructField { parent: self.into(), id })
            .collect()
    }
@@ -346,8 +344,7 @@ impl Struct {
        db.struct_data(self.id.into())
            .variant_data
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .find(|(_id, data)| data.name == *name)
            .map(|(id, _)| StructField { parent: self.into(), id })
    }
@@ -444,8 +441,7 @@ impl EnumVariant {
    pub fn fields(self, db: &impl HirDatabase) -> Vec<StructField> {
        self.variant_data(db)
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .map(|(id, _)| StructField { parent: self.into(), id })
            .collect()
    }
@@ -453,8 +449,7 @@ impl EnumVariant {
    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
        self.variant_data(db)
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .find(|(_id, data)| data.name == *name)
            .map(|(id, _)| StructField { parent: self.into(), id })
    }
@@ -510,7 +505,7 @@ impl VariantDef {
        }
    }
-    pub fn field(self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
+    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),
@@ -560,52 +555,6 @@ impl DefWithBody {
    }
 }
-pub trait HasBody: Copy {
-    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult>;
-    fn body(self, db: &impl HirDatabase) -> Arc<Body>;
-    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap>;
-    fn expr_scopes(self, db: &impl HirDatabase) -> Arc<ExprScopes>;
-}
-impl<T> HasBody for T
-where
-    T: Into<DefWithBody> + Copy + HasSource,
-{
-    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self.into())
-    }
-    fn body(self, db: &impl HirDatabase) -> Arc<Body> {
-        self.into().body(db)
-    }
-    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        self.into().body_source_map(db)
-    }
-    fn expr_scopes(self, db: &impl HirDatabase) -> Arc<ExprScopes> {
-        self.into().expr_scopes(db)
-    }
-}
-impl HasBody for DefWithBody {
-    fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(self)
-    }
-    fn body(self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body(self.into())
-    }
-    fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_with_source_map(self.into()).1
-    }
-    fn expr_scopes(self, db: &impl HirDatabase) -> Arc<ExprScopes> {
-        db.expr_scopes(self.into())
-    }
-}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Function {
    pub(crate) id: FunctionId,
@@ -632,7 +581,7 @@ impl Function {
        db.function_data(self.id).params.clone()
    }
-    pub(crate) fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+    pub fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
        db.body_with_source_map(self.id.into()).1
    }
@@ -966,7 +915,7 @@ pub struct Local {
 impl Local {
    pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
-        let body = self.parent.body(db);
+        let body = db.body(self.parent.into());
        match &body[self.pat_id] {
            Pat::Bind { name, .. } => Some(name.clone()),
            _ => None,
@@ -978,7 +927,7 @@ impl Local {
    }
    pub fn is_mut(self, db: &impl HirDatabase) -> bool {
-        let body = self.parent.body(db);
+        let body = db.body(self.parent.into());
        match &body[self.pat_id] {
            Pat::Bind { mode, .. } => match mode {
                BindingAnnotation::Mutable | BindingAnnotation::RefMut => true,
@@ -1002,7 +951,7 @@ impl Local {
    }
    pub fn source(self, db: &impl HirDatabase) -> Source<Either<ast::BindPat, ast::SelfParam>> {
-        let source_map = self.parent.body_source_map(db);
+        let (_body, source_map) = db.body_with_source_map(self.parent.into());
        let src = source_map.pat_syntax(self.pat_id).unwrap(); // Hmm...
        let root = src.file_syntax(db);
        src.map(|ast| ast.map(|it| it.cast().unwrap().to_node(&root), |it| it.to_node(&root)))
@@ -1020,6 +969,41 @@ pub struct ImplBlock {
    pub(crate) id: ImplId,
 }
+impl ImplBlock {
+    pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
+        db.impl_data(self.id).target_trait.clone()
+    }
+    pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
+        db.impl_data(self.id).target_type.clone()
+    }
+    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
+        Ty::from_hir(db, &self.id.resolver(db), &self.target_type(db))
+    }
+    pub fn target_trait_ref(&self, db: &impl HirDatabase) -> Option<TraitRef> {
+        let target_ty = self.target_ty(db);
+        TraitRef::from_hir(db, &self.id.resolver(db), &self.target_trait(db)?, Some(target_ty))
+    }
+    pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
+        db.impl_data(self.id).items.iter().map(|it| (*it).into()).collect()
+    }
+    pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
+        db.impl_data(self.id).is_negative
+    }
+    pub fn module(&self, db: &impl DefDatabase) -> Module {
+        self.id.module(db).into()
+    }
+    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
+        Crate { crate_id: self.module(db).id.krate }
+    }
+}
 /// For IDE only
 pub enum ScopeDef {
    ModuleDef(ModuleDef),
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index b9d21bdd7..a4e317c20 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -2,12 +2,11 @@
 use hir_def::{AstItemDef, HasChildSource, HasSource as _, Lookup, VariantId};
 use hir_expand::either::Either;
-use ra_syntax::ast::{self, AstNode};
+use ra_syntax::ast;
 use crate::{
-    db::{DefDatabase, HirDatabase},
+    db::DefDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplBlock, Import, MacroDef,
-    Const, Enum, EnumVariant, FieldSource, Function, HasBody, Import, MacroDef, Module,
+    Module, ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
-    ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
 };
 pub use hir_expand::Source;
@@ -109,6 +108,12 @@ impl HasSource for MacroDef {
        Source { file_id: self.id.ast_id.file_id(), value: self.id.ast_id.to_node(db) }
    }
 }
+impl HasSource for ImplBlock {
+    type Ast = ast::ImplBlock;
+    fn source(self, db: &impl DefDatabase) -> Source<ast::ImplBlock> {
+        self.id.source(db)
+    }
+}
 impl HasSource for Import {
    type Ast = Either<ast::UseTree, ast::ExternCrateItem>;
@@ -121,27 +126,3 @@ impl HasSource for Import {
        src.with_value(ptr.map(|it| it.to_node(&root), |it| it.to_node(&root)))
    }
 }
-pub trait HasBodySource: HasBody + HasSource
-where
-    Self::Ast: AstNode,
-{
-    fn expr_source(
-        self,
-        db: &impl HirDatabase,
-        expr_id: crate::expr::ExprId,
-    ) -> Option<Source<Either<ast::Expr, ast::RecordField>>> {
-        let source_map = self.body_source_map(db);
-        let source_ptr = source_map.expr_syntax(expr_id)?;
-        let root = source_ptr.file_syntax(db);
-        let source = source_ptr.map(|ast| ast.map(|it| it.to_node(&root), |it| it.to_node(&root)));
-        Some(source)
-    }
-}
-impl<T> HasBodySource for T
-where
-    T: HasBody + HasSource,
-    T::Ast: AstNode,
-{
-}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index a9dab2d25..5084bbacf 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -2,6 +2,7 @@
 use std::sync::Arc;
+use ra_arena::map::ArenaMap;
 use ra_db::salsa;
 use crate::{
@@ -11,15 +12,19 @@ use crate::{
        CallableDef, FnSig, GenericPredicate, InferenceResult, Namespace, Substs, Ty, TypableDef,
        TypeCtor,
    },
-    Crate, DefWithBody, GenericDef, ImplBlock, StructField, Trait,
+    Crate, DefWithBody, GenericDef, ImplBlock, Trait,
 };
-pub use hir_def::db::{
+pub use hir_def::{
-    BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery,
+    db::{
-    DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery,
+        BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery,
-    FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage,
+        DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery,
-    LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, RawItemsWithSourceMapQuery,
+        FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase,
-    StaticDataQuery, StructDataQuery, TraitDataQuery, TypeAliasDataQuery,
+        InternDatabaseStorage, LangItemQuery, ModuleLangItemsQuery, RawItemsQuery,
+        RawItemsWithSourceMapQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
+        TypeAliasDataQuery,
+    },
+    LocalStructFieldId, VariantId,
 };
 pub use hir_expand::db::{
    AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
@@ -35,8 +40,8 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::ty::type_for_def)]
    fn type_for_def(&self, def: TypableDef, ns: Namespace) -> Ty;
-    #[salsa::invoke(crate::ty::type_for_field)]
+    #[salsa::invoke(crate::ty::field_types_query)]
-    fn type_for_field(&self, field: StructField) -> Ty;
+    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Ty>>;
    #[salsa::invoke(crate::ty::callable_item_sig)]
    fn callable_item_signature(&self, def: CallableDef) -> FnSig;
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 6b703d8b4..43fedde7a 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -44,15 +44,15 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
    pub(crate) fn validate_body(&mut self, db: &impl HirDatabase) {
        let body = self.func.body(db);
-        for e in body.exprs() {
+        for e in body.exprs.iter() {
            if let (id, Expr::RecordLit { path, fields, spread }) = e {
                self.validate_record_literal(id, path, fields, *spread, db);
            }
        }
-        let body_expr = &body[body.body_expr()];
+        let body_expr = &body[body.body_expr];
        if let Expr::Block { statements: _, tail: Some(t) } = body_expr {
-            self.validate_results_in_tail_expr(body.body_expr(), *t, db);
+            self.validate_results_in_tail_expr(body.body_expr, *t, db);
        }
    }
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index f506bba70..1e7c22774 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -9,9 +9,9 @@ use ra_syntax::{
 use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
-    AssocItem, Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasBody, HasSource,
+    AssocItem, Const, DefWithBody, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock,
-    ImplBlock, Local, MacroDef, Module, ModuleDef, ModuleSource, Source, Static, Struct,
+    Local, MacroDef, Module, ModuleDef, ModuleSource, Source, Static, Struct, StructField, Trait,
-    StructField, Trait, TypeAlias, Union, VariantDef,
+    TypeAlias, Union, VariantDef,
 };
 pub trait FromSource: Sized {
@@ -200,8 +200,7 @@ impl FromSource for StructField {
        variant_def
            .variant_data(db)
            .fields()
-            .into_iter()
+            .iter()
-            .flat_map(|it| it.iter())
            .map(|(id, _)| StructField { parent: variant_def, id })
            .find(|f| f.source(db) == src)
    }
@@ -221,7 +220,7 @@ impl Local {
            };
            Some(res)
        })?;
-        let source_map = parent.body_source_map(db);
+        let (_body, source_map) = db.body_with_source_map(parent.into());
        let src = src.map(ast::Pat::from);
        let pat_id = source_map.node_pat(src.as_ref())?;
        Some(Local { parent, pat_id })
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
deleted file mode 100644
index 334eeebac..000000000
--- a/crates/ra_hir/src/impl_block.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-//! FIXME: write short doc here
-use hir_def::{resolver::HasResolver, type_ref::TypeRef, AstItemDef};
-use ra_syntax::ast;
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    ty::Ty,
-    AssocItem, Crate, HasSource, ImplBlock, Module, Source, TraitRef,
-};
-impl HasSource for ImplBlock {
-    type Ast = ast::ImplBlock;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ImplBlock> {
-        self.id.source(db)
-    }
-}
-impl ImplBlock {
-    pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.impl_data(self.id).target_trait.clone()
-    }
-    pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
-        db.impl_data(self.id).target_type.clone()
-    }
-    pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
-        Ty::from_hir(db, &self.id.resolver(db), &self.target_type(db))
-    }
-    pub fn target_trait_ref(&self, db: &impl HirDatabase) -> Option<TraitRef> {
-        let target_ty = self.target_ty(db);
-        TraitRef::from_hir(db, &self.id.resolver(db), &self.target_trait(db)?, Some(target_ty))
-    }
-    pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        db.impl_data(self.id).items.iter().map(|it| (*it).into()).collect()
-    }
-    pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
-        db.impl_data(self.id).is_negative
-    }
-    pub fn module(&self, db: &impl DefDatabase) -> Module {
-        self.id.module(db).into()
-    }
-    pub fn krate(&self, db: &impl DefDatabase) -> Crate {
-        Crate { crate_id: self.module(db).id.krate }
-    }
-}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 8c589c728..843ce6a88 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -32,7 +32,6 @@ pub mod db;
 pub mod source_binder;
 mod ty;
-mod impl_block;
 mod expr;
 pub mod diagnostics;
 mod util;
@@ -49,11 +48,10 @@ mod marks;
 pub use crate::{
    code_model::{
-        src::{HasBodySource, HasSource},
+        src::HasSource, Adt, AssocItem, AttrDef, Const, Container, Crate, CrateDependency,
-        Adt, AssocItem, AttrDef, Const, Container, Crate, CrateDependency, DefWithBody, Docs, Enum,
+        DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, GenericParam,
-        EnumVariant, FieldSource, Function, GenericDef, GenericParam, HasAttrs, HasBody, ImplBlock,
+        HasAttrs, ImplBlock, Import, Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef,
-        Import, Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef, Static, Struct,
+        Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
-        StructField, Trait, TypeAlias, Union, VariantDef,
    },
    expr::ExprScopes,
    from_source::FromSource,
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index cfc4bd326..31390bb7f 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -28,8 +28,7 @@ use crate::{
    expr::{BodySourceMap, ExprScopes, ScopeId},
    ty::method_resolution::{self, implements_trait},
    Adt, AssocItem, Const, DefWithBody, Either, Enum, EnumVariant, FromSource, Function,
-    GenericParam, HasBody, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Ty,
+    GenericParam, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Ty, TypeAlias,
-    TypeAlias,
 };
 fn try_get_resolver_for_node(db: &impl HirDatabase, node: Source<&SyntaxNode>) -> Option<Resolver> {
@@ -155,8 +154,8 @@ impl SourceAnalyzer {
    ) -> SourceAnalyzer {
        let def_with_body = def_with_body_from_child_node(db, node);
        if let Some(def) = def_with_body {
-            let source_map = def.body_source_map(db);
+            let (_body, source_map) = db.body_with_source_map(def.into());
-            let scopes = def.expr_scopes(db);
+            let scopes = db.expr_scopes(def.into());
            let scope = match offset {
                None => scope_for(&scopes, &source_map, node),
                Some(offset) => scope_for_offset(&scopes, &source_map, node.with_value(offset)),
@@ -166,7 +165,7 @@ impl SourceAnalyzer {
                resolver,
                body_owner: Some(def),
                body_source_map: Some(source_map),
-                infer: Some(def.infer(db)),
+                infer: Some(db.infer(def)),
                scopes: Some(scopes),
                file_id: node.file_id,
            }
@@ -216,6 +215,11 @@ impl SourceAnalyzer {
        self.infer.as_ref()?.field_resolution(expr_id)
    }
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<crate::StructField> {
+        let expr_id = self.expr_id(&field.expr()?)?;
+        self.infer.as_ref()?.record_field_resolution(expr_id)
+    }
    pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<crate::VariantDef> {
        let expr_id = self.expr_id(&record_lit.clone().into())?;
        self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
diff --git a/crates/ra_hir/src/test_db.rs b/crates/ra_hir/src/test_db.rs
index 03c7ac155..efee2f658 100644
--- a/crates/ra_hir/src/test_db.rs
+++ b/crates/ra_hir/src/test_db.rs
@@ -80,7 +80,7 @@ impl TestDB {
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter().next() {
            let crate_def_map = self.crate_def_map(krate);
-            for module_id in crate_def_map.modules() {
+            for (module_id, _) in crate_def_map.modules.iter() {
                let module_id = ModuleId { krate, module_id };
                let module = crate::Module::from(module_id);
                module.diagnostics(
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 309bd2727..f62316c1f 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -30,8 +30,9 @@ pub(crate) use autoderef::autoderef;
 pub(crate) use infer::{infer_query, InferTy, InferenceResult};
 pub use lower::CallableDef;
 pub(crate) use lower::{
-    callable_item_sig, generic_defaults_query, generic_predicates_for_param_query,
+    callable_item_sig, field_types_query, generic_defaults_query,
-    generic_predicates_query, type_for_def, type_for_field, Namespace, TypableDef,
+    generic_predicates_for_param_query, generic_predicates_query, type_for_def, Namespace,
+    TypableDef,
 };
 pub(crate) use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 471bdc387..ddc7d262a 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -44,8 +44,7 @@ use crate::{
    db::HirDatabase,
    expr::{BindingAnnotation, Body, ExprId, PatId},
    ty::infer::diagnostics::InferenceDiagnostic,
-    Adt, AssocItem, DefWithBody, FloatTy, Function, HasBody, IntTy, Path, StructField, Trait,
+    Adt, AssocItem, DefWithBody, FloatTy, Function, IntTy, Path, StructField, Trait, VariantDef,
-    VariantDef,
 };
 macro_rules! ty_app {
@@ -126,6 +125,8 @@ pub struct InferenceResult {
    method_resolutions: FxHashMap<ExprId, Function>,
    /// For each field access expr, records the field it resolves to.
    field_resolutions: FxHashMap<ExprId, StructField>,
+    /// For each field in record literal, records the field it resolves to.
+    record_field_resolutions: FxHashMap<ExprId, StructField>,
    /// For each struct literal, records the variant it resolves to.
    variant_resolutions: FxHashMap<ExprOrPatId, VariantDef>,
    /// For each associated item record what it resolves to
@@ -143,6 +144,9 @@ impl InferenceResult {
    pub fn field_resolution(&self, expr: ExprId) -> Option<StructField> {
        self.field_resolutions.get(&expr).copied()
    }
+    pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructField> {
+        self.record_field_resolutions.get(&expr).copied()
+    }
    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantDef> {
        self.variant_resolutions.get(&id.into()).copied()
    }
@@ -216,7 +220,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            coerce_unsized_map: Self::init_coerce_unsized_map(db, &resolver),
            db,
            owner,
-            body: owner.body(db),
+            body: db.body(owner.into()),
            resolver,
        }
    }
@@ -565,7 +569,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn collect_fn(&mut self, data: &FunctionData) {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
-        for (type_ref, pat) in data.params.iter().zip(body.params()) {
+        for (type_ref, pat) in data.params.iter().zip(body.params.iter()) {
            let ty = self.make_ty(type_ref);
            self.infer_pat(*pat, &ty, BindingMode::default());
@@ -574,7 +578,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
    fn infer_body(&mut self) {
-        self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone()));
+        self.infer_expr(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
    }
    fn resolve_into_iter_item(&self) -> Option<TypeAlias> {
diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index 4ea038d99..54765da35 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -245,14 +245,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                ty_app!(TypeCtor::Adt(Adt::Struct(struct1)), st1),
                ty_app!(TypeCtor::Adt(Adt::Struct(struct2)), st2),
            ) if struct1 == struct2 => {
-                let fields = struct1.fields(self.db);
+                let field_tys = self.db.field_types(struct1.id.into());
-                let (last_field, prev_fields) = fields.split_last()?;
+                let struct_data = self.db.struct_data(struct1.id.0);
+                let mut fields = struct_data.variant_data.fields().iter();
+                let (last_field_id, _data) = fields.next_back()?;
                // Get the generic parameter involved in the last field.
                let unsize_generic_index = {
                    let mut index = None;
                    let mut multiple_param = false;
-                    last_field.ty(self.db).walk(&mut |ty| match ty {
+                    field_tys[last_field_id].walk(&mut |ty| match ty {
                        &Ty::Param { idx, .. } => {
                            if index.is_none() {
                                index = Some(idx);
@@ -271,8 +274,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                // Check other fields do not involve it.
                let mut multiple_used = false;
-                prev_fields.iter().for_each(|field| {
+                fields.for_each(|(field_id, _data)| {
-                    field.ty(self.db).walk(&mut |ty| match ty {
+                    field_tys[field_id].walk(&mut |ty| match ty {
                        &Ty::Param { idx, .. } if idx == unsize_generic_index => {
                            multiple_used = true
                        }
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 20a7e9352..663ff9435 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -214,19 +214,24 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                self.unify(&ty, &expected.ty);
                let substs = ty.substs().unwrap_or_else(Substs::empty);
+                let field_types =
+                    def_id.map(|it| self.db.field_types(it.into())).unwrap_or_default();
                for (field_idx, field) in fields.iter().enumerate() {
-                    let field_ty = def_id
+                    let field_def = def_id.and_then(|it| match it.field(self.db, &field.name) {
-                        .and_then(|it| match it.field(self.db, &field.name) {
+                        Some(field) => Some(field),
-                            Some(field) => Some(field),
+                        None => {
-                            None => {
+                            self.push_diagnostic(InferenceDiagnostic::NoSuchField {
-                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
+                                expr: tgt_expr,
-                                    expr: tgt_expr,
+                                field: field_idx,
-                                    field: field_idx,
+                            });
-                                });
+                            None
-                                None
+                        }
-                            }
+                    });
-                        })
+                    if let Some(field_def) = field_def {
-                        .map_or(Ty::Unknown, |field| field.ty(self.db))
+                        self.result.record_field_resolutions.insert(field.expr, field_def);
+                    }
+                    let field_ty = field_def
+                        .map_or(Ty::Unknown, |it| field_types[it.id].clone())
                        .subst(&substs);
                    self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
                }
@@ -250,7 +255,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
                        TypeCtor::Adt(Adt::Struct(s)) => s.field(self.db, name).map(|field| {
                            self.write_field_resolution(tgt_expr, field);
-                            field.ty(self.db).subst(&a_ty.parameters)
+                            self.db.field_types(s.id.into())[field.id]
+                                .clone()
+                                .subst(&a_ty.parameters)
                        }),
                        _ => None,
                    },
diff --git a/crates/ra_hir/src/ty/infer/pat.rs b/crates/ra_hir/src/ty/infer/pat.rs
index c125ddfbc..641d61e87 100644
--- a/crates/ra_hir/src/ty/infer/pat.rs
+++ b/crates/ra_hir/src/ty/infer/pat.rs
@@ -27,10 +27,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        let field_tys = def.map(|it| self.db.field_types(it.into())).unwrap_or_default();
        for (i, &subpat) in subpats.iter().enumerate() {
            let expected_ty = def
                .and_then(|d| d.field(self.db, &Name::new_tuple_field(i)))
-                .map_or(Ty::Unknown, |field| field.ty(self.db))
+                .map_or(Ty::Unknown, |field| field_tys[field.id].clone())
                .subst(&substs);
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat, &expected_ty, default_bm);
@@ -56,10 +57,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let substs = ty.substs().unwrap_or_else(Substs::empty);
+        let field_tys = def.map(|it| self.db.field_types(it.into())).unwrap_or_default();
        for subpat in subpats {
            let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
-            let expected_ty =
+            let expected_ty = matching_field
-                matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
+                .map_or(Ty::Unknown, |field| field_tys[field.id].clone())
+                .subst(&substs);
            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat.pat, &expected_ty, default_bm);
        }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 2272510e8..a39beb2a0 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -14,8 +14,9 @@ use hir_def::{
    path::{GenericArg, PathSegment},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{TypeBound, TypeRef},
-    AdtId, GenericDefId,
+    AdtId, GenericDefId, LocalStructFieldId, VariantId,
 };
+use ra_arena::map::ArenaMap;
 use super::{
    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
@@ -29,7 +30,7 @@ use crate::{
    },
    util::make_mut_slice,
    Const, Enum, EnumVariant, Function, GenericDef, ImplBlock, ModuleDef, Path, Static, Struct,
-    StructField, Trait, TypeAlias, Union, VariantDef,
+    Trait, TypeAlias, Union,
 };
 // FIXME: this is only really used in `type_for_def`, which contains a bunch of
@@ -549,16 +550,23 @@ pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSi
    }
 }
-/// Build the type of a specific field of a struct or enum variant.
+/// Build the type of all specific fields of a struct or enum variant.
-pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
+pub(crate) fn field_types_query(
-    let parent_def = field.parent_def(db);
+    db: &impl HirDatabase,
-    let resolver = match parent_def {
+    variant_id: VariantId,
-        VariantDef::Struct(it) => it.id.resolver(db),
+) -> Arc<ArenaMap<LocalStructFieldId, Ty>> {
-        VariantDef::EnumVariant(it) => it.parent.id.resolver(db),
+    let (resolver, var_data) = match variant_id {
+        VariantId::StructId(it) => (it.resolver(db), db.struct_data(it.0).variant_data.clone()),
+        VariantId::EnumVariantId(it) => (
+            it.parent.resolver(db),
+            db.enum_data(it.parent).variants[it.local_id].variant_data.clone(),
+        ),
    };
-    let var_data = parent_def.variant_data(db);
+    let mut res = ArenaMap::default();
-    let type_ref = &var_data.fields().unwrap()[field.id].type_ref;
+    for (field_id, field_data) in var_data.fields().iter() {
-    Ty::from_hir(db, &resolver, type_ref)
+        res.insert(field_id, Ty::from_hir(db, &resolver, &field_data.type_ref))
+    }
+    Arc::new(res)
 }
 /// This query exists only to be used when resolving short-hand associated types
@@ -696,10 +704,7 @@ impl From<Option<BuiltinFloat>> for Uncertain<FloatTy> {
 fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
    let struct_data = db.struct_data(def.id.into());
-    let fields = match struct_data.variant_data.fields() {
+    let fields = struct_data.variant_data.fields();
-        Some(fields) => fields,
-        None => panic!("fn_sig_for_struct_constructor called on unit struct"),
-    };
    let resolver = def.id.resolver(db);
    let params = fields
        .iter()
@@ -712,7 +717,7 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
 /// Build the type of a tuple struct constructor.
 fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
    let struct_data = db.struct_data(def.id.into());
-    if struct_data.variant_data.fields().is_none() {
+    if struct_data.variant_data.is_unit() {
        return type_for_adt(db, def); // Unit struct
    }
    let generics = db.generic_params(def.id.into());
@@ -722,10 +727,7 @@ fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
 fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
    let var_data = def.variant_data(db);
-    let fields = match var_data.fields() {
+    let fields = var_data.fields();
-        Some(fields) => fields,
-        None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"),
-    };
    let resolver = def.parent.id.resolver(db);
    let params = fields
        .iter()
@@ -740,7 +742,7 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant)
 /// Build the type of a tuple enum variant constructor.
 fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
    let var_data = def.variant_data(db);
-    if var_data.fields().is_none() {
+    if var_data.is_unit() {
        return type_for_adt(db, def.parent_enum(db)); // Unit variant
    }
    let generics = db.generic_params(def.parent_enum(db).id.into());
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 9efdc53c4..1a93e5e50 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -19,7 +19,7 @@ use crate::{
    db::HirDatabase,
    ty::display::HirDisplay,
    ty::{ApplicationTy, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk},
-    Crate, GenericDef, HasBody, ImplBlock, Trait, TypeAlias,
+    Crate, GenericDef, ImplBlock, Trait, TypeAlias,
 };
 /// This represents a trait whose name we could not resolve.
@@ -715,7 +715,7 @@ fn closure_fn_trait_impl_datum(
    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
    fn_once_trait.associated_type_by_name(db, &name::OUTPUT_TYPE)?;
-    let num_args: u16 = match &data.def.body(db)[data.expr] {
+    let num_args: u16 = match &db.body(data.def.into())[data.expr] {
        crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
        _ => {
            log::warn!("closure for closure type {:?} not found", data);
@@ -805,7 +805,7 @@ fn closure_fn_trait_output_assoc_ty_value(
 ) -> Arc<AssociatedTyValue<ChalkIr>> {
    let impl_id = Impl::ClosureFnTraitImpl(data.clone()).to_chalk(db);
-    let num_args: u16 = match &data.def.body(db)[data.expr] {
+    let num_args: u16 = match &db.body(data.def.into())[data.expr] {
        crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
        _ => {
            log::warn!("closure for closure type {:?} not found", data);