18 files changed, 352 insertions, 397 deletions
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 9f06b147c..534f1f8e9 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -6,15 +6,14 @@ use std::sync::Arc;
 use hir_def::{
    adt::VariantData,
-    body::scope::ExprScopes,
    builtin_type::BuiltinType,
    docs::Documentation,
    per_ns::PerNs,
    resolver::{HasResolver, TypeNs},
    type_ref::TypeRef,
-    AstItemDef, ConstId, ContainerId, EnumId, FunctionId, HasModule, ImplId, LocalEnumVariantId,
+    AstItemDef, ConstId, ContainerId, EnumId, FunctionId, GenericDefId, HasModule, ImplId,
-    LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId,
+    LocalEnumVariantId, LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId,
-    TraitId, TypeAliasId, UnionId,
+    StaticId, StructId, TraitId, TypeAliasId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
@@ -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
@@ -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
    }
@@ -948,16 +897,6 @@ impl_froms!(
    Const
 );
-impl From<AssocItem> for GenericDef {
-    fn from(item: AssocItem) -> Self {
-        match item {
-            AssocItem::Function(f) => f.into(),
-            AssocItem::Const(c) => c.into(),
-            AssocItem::TypeAlias(t) => t.into(),
-        }
-    }
-}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Local {
    pub(crate) parent: DefWithBody,
@@ -966,7 +905,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 +917,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 +941,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)))
@@ -1011,7 +950,7 @@ impl Local {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct GenericParam {
-    pub(crate) parent: GenericDef,
+    pub(crate) parent: GenericDefId,
    pub(crate) idx: u32,
 }
@@ -1020,6 +959,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..b034d4e44 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, 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,
+    },
+    GenericDefId, 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;
@@ -44,15 +49,15 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::ty::generic_predicates_for_param_query)]
    fn generic_predicates_for_param(
        &self,
-        def: GenericDef,
+        def: GenericDefId,
        param_idx: u32,
    ) -> Arc<[GenericPredicate]>;
    #[salsa::invoke(crate::ty::generic_predicates_query)]
-    fn generic_predicates(&self, def: GenericDef) -> Arc<[GenericPredicate]>;
+    fn generic_predicates(&self, def: GenericDefId) -> Arc<[GenericPredicate]>;
    #[salsa::invoke(crate::ty::generic_defaults_query)]
-    fn generic_defaults(&self, def: GenericDef) -> Substs;
+    fn generic_defaults(&self, def: GenericDefId) -> Substs;
    #[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/from_id.rs b/crates/ra_hir/src/from_id.rs
index 529ac8251..619f6055e 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -9,9 +9,8 @@ use hir_def::{
 };
 use crate::{
-    ty::{CallableDef, TypableDef},
+    ty::TypableDef, Adt, AssocItem, AttrDef, Const, Crate, DefWithBody, EnumVariant, Function,
-    Adt, AssocItem, AttrDef, Const, Crate, DefWithBody, EnumVariant, Function, GenericDef,
+    GenericDef, ModuleDef, Static, StructField, TypeAlias, VariantDef,
-    ModuleDef, Static, StructField, TypeAlias, VariantDef,
 };
 impl From<ra_db::CrateId> for Crate {
@@ -138,20 +137,6 @@ impl From<GenericDef> for GenericDefId {
    }
 }
-impl From<GenericDefId> for GenericDef {
-    fn from(def: GenericDefId) -> Self {
-        match def {
-            GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
-            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
-            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
-            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
-            GenericDefId::ImplId(it) => GenericDef::ImplBlock(it.into()),
-            GenericDefId::EnumVariantId(it) => GenericDef::EnumVariant(it.into()),
-            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
-        }
-    }
-}
 impl From<AdtId> for TypableDef {
    fn from(id: AdtId) -> Self {
        Adt::from(id).into()
@@ -214,18 +199,6 @@ impl From<Adt> for GenericDefId {
    }
 }
-impl From<CallableDef> for GenericDefId {
-    fn from(def: CallableDef) -> Self {
-        match def {
-            CallableDef::Function(it) => it.id.into(),
-            CallableDef::Struct(it) => it.id.into(),
-            CallableDef::EnumVariant(it) => {
-                EnumVariantId { parent: it.parent.id, local_id: it.id }.into()
-            }
-        }
-    }
-}
 impl From<VariantDef> for VariantId {
    fn from(def: VariantDef) -> Self {
        match def {
@@ -257,3 +230,13 @@ impl From<AttrDef> for AttrDefId {
        }
    }
 }
+impl From<AssocItem> for GenericDefId {
+    fn from(item: AssocItem) -> Self {
+        match item {
+            AssocItem::Function(f) => f.id.into(),
+            AssocItem::Const(c) => c.id.into(),
+            AssocItem::TypeAlias(t) => t.id.into(),
+        }
+    }
+}
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..cbfeca3ab 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -26,10 +26,12 @@ use ra_syntax::{
 use crate::{
    db::HirDatabase,
    expr::{BodySourceMap, ExprScopes, ScopeId},
-    ty::method_resolution::{self, implements_trait},
+    ty::{
+        method_resolution::{self, implements_trait},
+        TraitEnvironment,
+    },
    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 +157,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 +168,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 +218,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)
@@ -244,7 +251,7 @@ impl SourceAnalyzer {
        let types = self.resolver.resolve_path_in_type_ns_fully(db, &path).map(|ty| match ty {
            TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
            TypeNs::GenericParam(idx) => PathResolution::GenericParam(GenericParam {
-                parent: self.resolver.generic_def().unwrap().into(),
+                parent: self.resolver.generic_def().unwrap(),
                idx,
            }),
            TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
@@ -319,7 +326,7 @@ impl SourceAnalyzer {
                resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
                resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
                resolver::ScopeDef::GenericParam(idx) => {
-                    let parent = self.resolver.generic_def().unwrap().into();
+                    let parent = self.resolver.generic_def().unwrap();
                    ScopeDef::GenericParam(GenericParam { parent, idx })
                }
                resolver::ScopeDef::Local(pat_id) => {
@@ -404,7 +411,10 @@ impl SourceAnalyzer {
        // There should be no inference vars in types passed here
        // FIXME check that?
        let canonical = crate::ty::Canonical { value: ty, num_vars: 0 };
-        crate::ty::autoderef(db, &self.resolver, canonical).map(|canonical| canonical.value)
+        let krate = self.resolver.krate();
+        let environment = TraitEnvironment::lower(db, &self.resolver);
+        let ty = crate::ty::InEnvironment { value: canonical, environment };
+        crate::ty::autoderef(db, krate, ty).map(|canonical| canonical.value)
    }
    /// Checks that particular type `ty` implements `std::future::Future`.
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 309bd2727..8c045aaef 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -17,12 +17,12 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::{fmt, iter, mem};
-use hir_def::{generics::GenericParams, AdtId};
+use hir_def::{generics::GenericParams, AdtId, GenericDefId};
 use ra_db::{impl_intern_key, salsa};
 use crate::{
-    db::HirDatabase, expr::ExprId, util::make_mut_slice, Adt, Crate, DefWithBody, FloatTy,
+    db::HirDatabase, expr::ExprId, util::make_mut_slice, Adt, Crate, DefWithBody, FloatTy, IntTy,
-    GenericDef, IntTy, Mutability, Name, Trait, TypeAlias, Uncertain,
+    Mutability, Name, Trait, TypeAlias, Uncertain,
 };
 use display::{HirDisplay, HirFormatter};
@@ -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};
@@ -170,12 +171,12 @@ impl TypeCtor {
            | TypeCtor::Tuple { .. } => None,
            TypeCtor::Closure { def, .. } => def.krate(db),
            TypeCtor::Adt(adt) => adt.krate(db),
-            TypeCtor::FnDef(callable) => callable.krate(db),
+            TypeCtor::FnDef(callable) => Some(callable.krate(db).into()),
            TypeCtor::AssociatedType(type_alias) => type_alias.krate(db),
        }
    }
-    pub fn as_generic_def(self) -> Option<crate::GenericDef> {
+    pub fn as_generic_def(self) -> Option<GenericDefId> {
        match self {
            TypeCtor::Bool
            | TypeCtor::Char
@@ -192,7 +193,7 @@ impl TypeCtor {
            | TypeCtor::Closure { .. } => None,
            TypeCtor::Adt(adt) => Some(adt.into()),
            TypeCtor::FnDef(callable) => Some(callable.into()),
-            TypeCtor::AssociatedType(type_alias) => Some(type_alias.into()),
+            TypeCtor::AssociatedType(type_alias) => Some(type_alias.id.into()),
        }
    }
 }
@@ -355,9 +356,9 @@ impl Substs {
        )
    }
-    pub fn build_for_def(db: &impl HirDatabase, def: impl Into<GenericDef>) -> SubstsBuilder {
+    pub fn build_for_def(db: &impl HirDatabase, def: impl Into<GenericDefId>) -> SubstsBuilder {
        let def = def.into();
-        let params = db.generic_params(def.into());
+        let params = db.generic_params(def);
        let param_count = params.count_params_including_parent();
        Substs::builder(param_count)
    }
@@ -855,13 +856,20 @@ impl HirDisplay for ApplicationTy {
            TypeCtor::FnDef(def) => {
                let sig = f.db.callable_item_signature(def);
                let name = match def {
-                    CallableDef::Function(ff) => ff.name(f.db),
+                    CallableDef::FunctionId(ff) => f.db.function_data(ff).name.clone(),
-                    CallableDef::Struct(s) => s.name(f.db).unwrap_or_else(Name::missing),
+                    CallableDef::StructId(s) => {
-                    CallableDef::EnumVariant(e) => e.name(f.db).unwrap_or_else(Name::missing),
+                        f.db.struct_data(s.0).name.clone().unwrap_or_else(Name::missing)
+                    }
+                    CallableDef::EnumVariantId(e) => {
+                        let enum_data = f.db.enum_data(e.parent);
+                        enum_data.variants[e.local_id].name.clone().unwrap_or_else(Name::missing)
+                    }
                };
                match def {
-                    CallableDef::Function(_) => write!(f, "fn {}", name)?,
+                    CallableDef::FunctionId(_) => write!(f, "fn {}", name)?,
-                    CallableDef::Struct(_) | CallableDef::EnumVariant(_) => write!(f, "{}", name)?,
+                    CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {
+                        write!(f, "{}", name)?
+                    }
                }
                if self.parameters.len() > 0 {
                    write!(f, "<")?;
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index 41c99d227..44547197c 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -5,42 +5,49 @@
 use std::iter::successors;
-use hir_def::{lang_item::LangItemTarget, resolver::Resolver};
+use hir_def::lang_item::LangItemTarget;
 use hir_expand::name;
 use log::{info, warn};
+use ra_db::CrateId;
 use crate::{db::HirDatabase, Trait};
-use super::{traits::Solution, Canonical, Substs, Ty, TypeWalk};
+use super::{
+    traits::{InEnvironment, Solution},
+    Canonical, Substs, Ty, TypeWalk,
+};
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
 pub(crate) fn autoderef<'a>(
    db: &'a impl HirDatabase,
-    resolver: &'a Resolver,
+    krate: Option<CrateId>,
-    ty: Canonical<Ty>,
+    ty: InEnvironment<Canonical<Ty>>,
 ) -> impl Iterator<Item = Canonical<Ty>> + 'a {
-    successors(Some(ty), move |ty| deref(db, resolver, ty)).take(AUTODEREF_RECURSION_LIMIT)
+    let InEnvironment { value: ty, environment } = ty;
+    successors(Some(ty), move |ty| {
+        deref(db, krate?, InEnvironment { value: ty, environment: environment.clone() })
+    })
+    .take(AUTODEREF_RECURSION_LIMIT)
 }
 pub(crate) fn deref(
    db: &impl HirDatabase,
-    resolver: &Resolver,
+    krate: CrateId,
-    ty: &Canonical<Ty>,
+    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
-    if let Some(derefed) = ty.value.builtin_deref() {
+    if let Some(derefed) = ty.value.value.builtin_deref() {
-        Some(Canonical { value: derefed, num_vars: ty.num_vars })
+        Some(Canonical { value: derefed, num_vars: ty.value.num_vars })
    } else {
-        deref_by_trait(db, resolver, ty)
+        deref_by_trait(db, krate, ty)
    }
 }
 fn deref_by_trait(
    db: &impl HirDatabase,
-    resolver: &Resolver,
+    krate: CrateId,
-    ty: &Canonical<Ty>,
+    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
-    let krate = resolver.krate()?;
    let deref_trait = match db.lang_item(krate.into(), "deref".into())? {
        LangItemTarget::TraitId(t) => Trait::from(t),
        _ => return None,
@@ -56,10 +63,8 @@ fn deref_by_trait(
    // FIXME make the Canonical handling nicer
-    let env = super::lower::trait_env(db, resolver);
    let parameters = Substs::build_for_generics(&generic_params)
-        .push(ty.value.clone().shift_bound_vars(1))
+        .push(ty.value.value.clone().shift_bound_vars(1))
        .build();
    let projection = super::traits::ProjectionPredicate {
@@ -69,9 +74,9 @@ fn deref_by_trait(
    let obligation = super::Obligation::Projection(projection);
-    let in_env = super::traits::InEnvironment { value: obligation, environment: env };
+    let in_env = InEnvironment { value: obligation, environment: ty.environment };
-    let canonical = super::Canonical { num_vars: 1 + ty.num_vars, value: in_env };
+    let canonical = super::Canonical { num_vars: 1 + ty.value.num_vars, value: in_env };
    let solution = db.trait_solve(krate.into(), canonical)?;
@@ -89,14 +94,14 @@ fn deref_by_trait(
            // the case.
            for i in 1..vars.0.num_vars {
                if vars.0.value[i] != Ty::Bound((i - 1) as u32) {
-                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty, solution);
+                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
                    return None;
                }
            }
            Some(Canonical { value: vars.0.value[0].clone(), num_vars: vars.0.num_vars })
        }
        Solution::Ambig(_) => {
-            info!("Ambiguous solution for derefing {:?}: {:?}", ty, solution);
+            info!("Ambiguous solution for derefing {:?}: {:?}", ty.value, solution);
            None
        }
    }
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 2e744e5ec..6fd00d457 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -34,7 +34,6 @@ use ra_prof::profile;
 use test_utils::tested_by;
 use super::{
-    lower,
    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
    ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypableDef,
    TypeCtor, TypeWalk, Uncertain,
@@ -44,8 +43,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 +124,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 +143,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()
    }
@@ -212,11 +215,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            var_unification_table: InPlaceUnificationTable::new(),
            obligations: Vec::default(),
            return_ty: Ty::Unknown, // set in collect_fn_signature
-            trait_env: lower::trait_env(db, &resolver),
+            trait_env: TraitEnvironment::lower(db, &resolver),
            coerce_unsized_map: Self::init_coerce_unsized_map(db, &resolver),
            db,
            owner,
-            body: owner.body(db),
+            body: db.body(owner.into()),
            resolver,
        }
    }
diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index 4ea038d99..4b53bba73 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -14,7 +14,7 @@ use crate::{
    Adt, Mutability,
 };
-use super::{InferTy, InferenceContext, TypeVarValue};
+use super::{InEnvironment, InferTy, InferenceContext, TypeVarValue};
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    /// Unify two types, but may coerce the first one to the second one
@@ -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
                        }
@@ -317,9 +320,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let canonicalized = self.canonicalizer().canonicalize_ty(from_ty.clone());
        let to_ty = self.resolve_ty_shallow(&to_ty);
        // FIXME: Auto DerefMut
-        for derefed_ty in
+        for derefed_ty in autoderef::autoderef(
-            autoderef::autoderef(self.db, &self.resolver.clone(), canonicalized.value.clone())
+            self.db,
-        {
+            self.resolver.krate(),
+            InEnvironment {
+                value: canonicalized.value.clone(),
+                environment: self.trait_env.clone(),
+            },
+        ) {
            let derefed_ty = canonicalized.decanonicalize_ty(derefed_ty.value);
            match (&*self.resolve_ty_shallow(&derefed_ty), &*to_ty) {
                // Stop when constructor matches.
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 20a7e9352..1d6df2b7a 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -8,6 +8,7 @@ use hir_def::{
    generics::GenericParams,
    path::{GenericArg, GenericArgs},
    resolver::resolver_for_expr,
+    ContainerId, Lookup,
 };
 use hir_expand::name;
@@ -15,9 +16,9 @@ use crate::{
    db::HirDatabase,
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    ty::{
-        autoderef, method_resolution, op, CallableDef, InferTy, IntTy, Mutability, Namespace,
+        autoderef, method_resolution, op, traits::InEnvironment, CallableDef, InferTy, IntTy,
-        Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
+        Mutability, Namespace, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
-        Uncertain,
+        TypeCtor, TypeWalk, Uncertain,
    },
    Adt, Name,
 };
@@ -214,19 +215,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));
                }
@@ -240,8 +246,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let canonicalized = self.canonicalizer().canonicalize_ty(receiver_ty);
                let ty = autoderef::autoderef(
                    self.db,
-                    &self.resolver.clone(),
+                    self.resolver.krate(),
-                    canonicalized.value.clone(),
+                    InEnvironment {
+                        value: canonicalized.value.clone(),
+                        environment: self.trait_env.clone(),
+                    },
                )
                .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
                    Ty::Apply(a_ty) => match a_ty.ctor {
@@ -250,7 +259,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,
                    },
@@ -330,16 +341,25 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            Expr::UnaryOp { expr, op } => {
                let inner_ty = self.infer_expr(*expr, &Expectation::none());
                match op {
-                    UnaryOp::Deref => {
+                    UnaryOp::Deref => match self.resolver.krate() {
-                        let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
+                        Some(krate) => {
-                        if let Some(derefed_ty) =
+                            let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
-                            autoderef::deref(self.db, &self.resolver, &canonicalized.value)
+                            match autoderef::deref(
-                        {
+                                self.db,
-                            canonicalized.decanonicalize_ty(derefed_ty.value)
+                                krate,
-                        } else {
+                                InEnvironment {
-                            Ty::Unknown
+                                    value: &canonicalized.value,
+                                    environment: self.trait_env.clone(),
+                                },
+                            ) {
+                                Some(derefed_ty) => {
+                                    canonicalized.decanonicalize_ty(derefed_ty.value)
+                                }
+                                None => Ty::Unknown,
+                            }
                        }
-                    }
+                        None => Ty::Unknown,
+                    },
                    UnaryOp::Neg => {
                        match &inner_ty {
                            Ty::Apply(a_ty) => match a_ty.ctor {
@@ -641,18 +661,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                }
                // add obligation for trait implementation, if this is a trait method
                match def {
-                    CallableDef::Function(f) => {
+                    CallableDef::FunctionId(f) => {
-                        if let Some(trait_) = f.parent_trait(self.db) {
+                        if let ContainerId::TraitId(trait_) = f.lookup(self.db).container {
                            // construct a TraitDef
                            let substs = a_ty.parameters.prefix(
                                self.db
-                                    .generic_params(trait_.id.into())
+                                    .generic_params(trait_.into())
                                    .count_params_including_parent(),
                            );
-                            self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
+                            self.obligations.push(Obligation::Trait(TraitRef {
+                                trait_: trait_.into(),
+                                substs,
+                            }));
                        }
                    }
-                    CallableDef::Struct(_) | CallableDef::EnumVariant(_) => {}
+                    CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {}
                }
            }
        }
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/infer/path.rs b/crates/ra_hir/src/ty/infer/path.rs
index ee54d8217..6165eba4f 100644
--- a/crates/ra_hir/src/ty/infer/path.rs
+++ b/crates/ra_hir/src/ty/infer/path.rs
@@ -203,7 +203,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    Container::ImplBlock(_) => self.find_self_types(&def, ty.clone()),
                    Container::Trait(t) => {
                        // we're picking this method
-                        let trait_substs = Substs::build_for_def(self.db, t)
+                        let trait_substs = Substs::build_for_def(self.db, t.id)
                            .push(ty.clone())
                            .fill(std::iter::repeat_with(|| self.new_type_var()))
                            .build();
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 2272510e8..27cfe00c1 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -14,12 +14,15 @@ use hir_def::{
    path::{GenericArg, PathSegment},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{TypeBound, TypeRef},
-    AdtId, GenericDefId,
+    AdtId, AstItemDef, EnumVariantId, FunctionId, GenericDefId, HasModule, LocalStructFieldId,
+    Lookup, StructId, VariantId,
 };
+use ra_arena::map::ArenaMap;
+use ra_db::CrateId;
 use super::{
-    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef,
-    TypeWalk,
+    Ty, TypeCtor, TypeWalk,
 };
 use crate::{
    db::HirDatabase,
@@ -28,8 +31,8 @@ use crate::{
        Adt,
    },
    util::make_mut_slice,
-    Const, Enum, EnumVariant, Function, GenericDef, ImplBlock, ModuleDef, Path, Static, Struct,
+    Const, Enum, EnumVariant, Function, ImplBlock, ModuleDef, Path, Static, Struct, Trait,
-    StructField, Trait, TypeAlias, Union, VariantDef,
+    TypeAlias, Union,
 };
 // FIXME: this is only really used in `type_for_def`, which contains a bunch of
@@ -260,8 +263,10 @@ impl Ty {
        let traits = traits_from_env.flat_map(|t| t.all_super_traits(db));
        for t in traits {
            if let Some(associated_ty) = t.associated_type_by_name(db, &segment.name) {
-                let substs =
+                let substs = Substs::build_for_def(db, t.id)
-                    Substs::build_for_def(db, t).push(self_ty.clone()).fill_with_unknown().build();
+                    .push(self_ty.clone())
+                    .fill_with_unknown()
+                    .build();
                // FIXME handle type parameters on the segment
                return Ty::Projection(ProjectionTy { associated_ty, parameters: substs });
            }
@@ -286,11 +291,11 @@ impl Ty {
        segment: &PathSegment,
        resolved: TypableDef,
    ) -> Substs {
-        let def_generic: Option<GenericDef> = match resolved {
+        let def_generic: Option<GenericDefId> = match resolved {
-            TypableDef::Function(func) => Some(func.into()),
+            TypableDef::Function(func) => Some(func.id.into()),
            TypableDef::Adt(adt) => Some(adt.into()),
-            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
+            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).id.into()),
-            TypableDef::TypeAlias(t) => Some(t.into()),
+            TypableDef::TypeAlias(t) => Some(t.id.into()),
            TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::BuiltinType(_) => None,
        };
        substs_from_path_segment(db, resolver, segment, def_generic, false)
@@ -337,7 +342,7 @@ pub(super) fn substs_from_path_segment(
    db: &impl HirDatabase,
    resolver: &Resolver,
    segment: &PathSegment,
-    def_generic: Option<GenericDef>,
+    def_generic: Option<GenericDefId>,
    add_self_param: bool,
 ) -> Substs {
    let mut substs = Vec::new();
@@ -375,7 +380,7 @@ pub(super) fn substs_from_path_segment(
    // handle defaults
    if let Some(def_generic) = def_generic {
-        let default_substs = db.generic_defaults(def_generic);
+        let default_substs = db.generic_defaults(def_generic.into());
        assert_eq!(substs.len(), default_substs.len());
        for (i, default_ty) in default_substs.iter().enumerate() {
@@ -438,7 +443,7 @@ impl TraitRef {
    ) -> Substs {
        let has_self_param =
            segment.args_and_bindings.as_ref().map(|a| a.has_self_type).unwrap_or(false);
-        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), !has_self_param)
+        substs_from_path_segment(db, resolver, segment, Some(resolved.id.into()), !has_self_param)
    }
    pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef {
@@ -543,22 +548,29 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
 /// Build the signature of a callable item (function, struct or enum variant).
 pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
    match def {
-        CallableDef::Function(f) => fn_sig_for_fn(db, f),
+        CallableDef::FunctionId(f) => fn_sig_for_fn(db, f),
-        CallableDef::Struct(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDef::StructId(s) => fn_sig_for_struct_constructor(db, s),
-        CallableDef::EnumVariant(e) => fn_sig_for_enum_variant_constructor(db, e),
+        CallableDef::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
    }
 }
-/// 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
@@ -571,10 +583,10 @@ pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
 /// these are fine: `T: Foo<U::Item>, U: Foo<()>`.
 pub(crate) fn generic_predicates_for_param_query(
    db: &impl HirDatabase,
-    def: GenericDef,
+    def: GenericDefId,
    param_idx: u32,
 ) -> Arc<[GenericPredicate]> {
-    let resolver = GenericDefId::from(def).resolver(db);
+    let resolver = def.resolver(db);
    resolver
        .where_predicates_in_scope()
        // we have to filter out all other predicates *first*, before attempting to lower them
@@ -583,24 +595,23 @@ pub(crate) fn generic_predicates_for_param_query(
        .collect()
 }
-pub(crate) fn trait_env(
+impl TraitEnvironment {
-    db: &impl HirDatabase,
+    pub(crate) fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
-    resolver: &Resolver,
+        let predicates = resolver
-) -> Arc<super::TraitEnvironment> {
+            .where_predicates_in_scope()
-    let predicates = resolver
+            .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .where_predicates_in_scope()
+            .collect::<Vec<_>>();
-        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .collect::<Vec<_>>();
-    Arc::new(super::TraitEnvironment { predicates })
+        Arc::new(TraitEnvironment { predicates })
+    }
 }
 /// Resolve the where clause(s) of an item with generics.
 pub(crate) fn generic_predicates_query(
    db: &impl HirDatabase,
-    def: GenericDef,
+    def: GenericDefId,
 ) -> Arc<[GenericPredicate]> {
-    let resolver = GenericDefId::from(def).resolver(db);
+    let resolver = def.resolver(db);
    resolver
        .where_predicates_in_scope()
        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
@@ -608,8 +619,8 @@ pub(crate) fn generic_predicates_query(
 }
 /// Resolve the default type params from generics
-pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> Substs {
+pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDefId) -> Substs {
-    let resolver = GenericDefId::from(def).resolver(db);
+    let resolver = def.resolver(db);
    let generic_params = db.generic_params(def.into());
    let defaults = generic_params
@@ -621,9 +632,9 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) ->
    Substs(defaults)
 }
-fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
+fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> FnSig {
-    let data = db.function_data(def.id);
+    let data = db.function_data(def);
-    let resolver = def.id.resolver(db);
+    let resolver = def.resolver(db);
    let params = data.params.iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
    let ret = Ty::from_hir(db, &resolver, &data.ret_type);
    FnSig::from_params_and_return(params, ret)
@@ -634,7 +645,7 @@ fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
    let generics = db.generic_params(def.id.into());
    let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.id.into()), substs)
 }
 /// Build the declared type of a const.
@@ -694,58 +705,53 @@ impl From<Option<BuiltinFloat>> for Uncertain<FloatTy> {
    }
 }
-fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
+fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> FnSig {
-    let struct_data = db.struct_data(def.id.into());
+    let struct_data = db.struct_data(def.into());
-    let fields = match struct_data.variant_data.fields() {
+    let fields = struct_data.variant_data.fields();
-        Some(fields) => fields,
+    let resolver = def.resolver(db);
-        None => panic!("fn_sig_for_struct_constructor called on unit struct"),
-    };
-    let resolver = def.id.resolver(db);
    let params = fields
        .iter()
        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
        .collect::<Vec<_>>();
-    let ret = type_for_adt(db, def);
+    let ret = type_for_adt(db, Struct::from(def));
    FnSig::from_params_and_return(params, ret)
 }
 /// 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());
    let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.id.into()), substs)
 }
-fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
+fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> FnSig {
-    let var_data = def.variant_data(db);
+    let enum_data = db.enum_data(def.parent);
-    let fields = match var_data.fields() {
+    let var_data = &enum_data.variants[def.local_id];
-        Some(fields) => fields,
+    let fields = var_data.variant_data.fields();
-        None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"),
+    let resolver = def.parent.resolver(db);
-    };
-    let resolver = def.parent.id.resolver(db);
    let params = fields
        .iter()
        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
        .collect::<Vec<_>>();
-    let generics = db.generic_params(def.parent_enum(db).id.into());
+    let generics = db.generic_params(def.parent.into());
    let substs = Substs::identity(&generics);
-    let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs);
+    let ret = type_for_adt(db, Enum::from(def.parent)).subst(&substs);
    FnSig::from_params_and_return(params, ret)
 }
 /// 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());
    let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs)
 }
 fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt>) -> Ty {
@@ -802,28 +808,28 @@ impl From<ModuleDef> for Option<TypableDef> {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum CallableDef {
-    Function(Function),
+    FunctionId(FunctionId),
-    Struct(Struct),
+    StructId(StructId),
-    EnumVariant(EnumVariant),
+    EnumVariantId(EnumVariantId),
 }
-impl_froms!(CallableDef: Function, Struct, EnumVariant);
+impl_froms!(CallableDef: FunctionId, StructId, EnumVariantId);
 impl CallableDef {
-    pub fn krate(self, db: &impl HirDatabase) -> Option<crate::Crate> {
+    pub fn krate(self, db: &impl HirDatabase) -> CrateId {
        match self {
-            CallableDef::Function(f) => f.krate(db),
+            CallableDef::FunctionId(f) => f.lookup(db).module(db).krate,
-            CallableDef::Struct(s) => s.krate(db),
+            CallableDef::StructId(s) => s.0.module(db).krate,
-            CallableDef::EnumVariant(e) => e.parent_enum(db).krate(db),
+            CallableDef::EnumVariantId(e) => e.parent.module(db).krate,
        }
    }
 }
-impl From<CallableDef> for GenericDef {
+impl From<CallableDef> for GenericDefId {
-    fn from(def: CallableDef) -> GenericDef {
+    fn from(def: CallableDef) -> GenericDefId {
        match def {
-            CallableDef::Function(f) => f.into(),
+            CallableDef::FunctionId(f) => f.into(),
-            CallableDef::Struct(s) => s.into(),
+            CallableDef::StructId(s) => s.into(),
-            CallableDef::EnumVariant(e) => e.into(),
+            CallableDef::EnumVariantId(e) => e.into(),
        }
    }
 }
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index caa5f5f74..c5ab690eb 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -15,7 +15,7 @@ use crate::{
    AssocItem, Crate, Function, ImplBlock, Module, Mutability, Name, Trait,
 };
-use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
+use super::{autoderef, Canonical, InEnvironment, TraitEnvironment, TraitRef};
 /// This is used as a key for indexing impls.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -179,8 +179,9 @@ pub(crate) fn iterate_method_candidates<T>(
            // Also note that when we've got a receiver like &S, even if the method we
            // find in the end takes &self, we still do the autoderef step (just as
            // rustc does an autoderef and then autoref again).
+            let environment = TraitEnvironment::lower(db, resolver);
-            for derefed_ty in autoderef::autoderef(db, resolver, ty.clone()) {
+            let ty = InEnvironment { value: ty.clone(), environment };
+            for derefed_ty in autoderef::autoderef(db, resolver.krate(), ty) {
                if let Some(result) = iterate_inherent_methods(
                    &derefed_ty,
                    db,
@@ -230,7 +231,7 @@ fn iterate_trait_method_candidates<T>(
 ) -> Option<T> {
    let krate = resolver.krate()?;
    // FIXME: maybe put the trait_env behind a query (need to figure out good input parameters for that)
-    let env = lower::trait_env(db, resolver);
+    let env = TraitEnvironment::lower(db, resolver);
    // if ty is `impl Trait` or `dyn Trait`, the trait doesn't need to be in scope
    let inherent_trait = ty.value.inherent_trait().into_iter();
    // if we have `T: Trait` in the param env, the trait doesn't need to be in scope
@@ -324,7 +325,7 @@ pub(crate) fn implements_trait(
        // anyway, but currently Chalk doesn't implement `dyn/impl Trait` yet
        return true;
    }
-    let env = lower::trait_env(db, resolver);
+    let env = TraitEnvironment::lower(db, resolver);
    let goal = generic_implements_goal(db, env, trait_, ty.clone());
    let solution = db.trait_solve(krate, goal);
@@ -364,7 +365,7 @@ fn generic_implements_goal(
    self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::Obligation>> {
    let num_vars = self_ty.num_vars;
-    let substs = super::Substs::build_for_def(db, trait_)
+    let substs = super::Substs::build_for_def(db, trait_.id)
        .push(self_ty.value)
        .fill_with_bound_vars(num_vars as u32)
        .build();
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 9efdc53c4..0272dd9ae 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -9,7 +9,7 @@ use chalk_ir::{
 };
 use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
-use hir_def::lang_item::LangItemTarget;
+use hir_def::{lang_item::LangItemTarget, GenericDefId};
 use hir_expand::name;
 use ra_db::salsa::{InternId, InternKey};
@@ -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, ImplBlock, Trait, TypeAlias,
 };
 /// This represents a trait whose name we could not resolve.
@@ -402,7 +402,7 @@ fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T> {
 fn convert_where_clauses(
    db: &impl HirDatabase,
-    def: GenericDef,
+    def: GenericDefId,
    substs: &Substs,
 ) -> Vec<chalk_ir::QuantifiedWhereClause<ChalkIr>> {
    let generic_predicates = db.generic_predicates(def);
@@ -561,7 +561,7 @@ pub(crate) fn trait_datum_query(
        marker: false,
        fundamental: false,
    };
-    let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
+    let where_clauses = convert_where_clauses(db, trait_.id.into(), &bound_vars);
    let associated_ty_ids = trait_
        .items(db)
        .into_iter()
@@ -643,7 +643,7 @@ fn impl_block_datum(
    } else {
        chalk_rust_ir::ImplType::External
    };
-    let where_clauses = convert_where_clauses(db, impl_block.into(), &bound_vars);
+    let where_clauses = convert_where_clauses(db, impl_block.id.into(), &bound_vars);
    let negative = impl_block.is_negative(db);
    debug!(
        "impl {:?}: {}{} where {:?}",
@@ -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);
@@ -736,7 +736,7 @@ fn closure_fn_trait_impl_datum(
    let trait_ref = TraitRef {
        trait_,
-        substs: Substs::build_for_def(db, trait_).push(self_ty).push(arg_ty).build(),
+        substs: Substs::build_for_def(db, trait_.id).push(self_ty).push(arg_ty).build(),
    };
    let output_ty_id = AssocTyValue::ClosureFnTraitImplOutput(data.clone()).to_chalk(db);
@@ -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);