4 files changed, 79 insertions, 45 deletions

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 (last_field, prev_fields) = fields.split_last()?;
+                let field_tys = self.db.field_types(struct1.id.into());
+                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| {
-                    field.ty(self.db).walk(&mut |ty| match ty {
+                fields.for_each(|(field_id, _data)| {
+                    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
-            autoderef::autoderef(self.db, &self.resolver.clone(), canonicalized.value.clone())
-        {
+        for derefed_ty in autoderef::autoderef(
+            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,
-        Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
-        Uncertain,
+        autoderef, method_resolution, op, traits::InEnvironment, CallableDef, InferTy, IntTy,
+        Mutability, Namespace, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
+        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
-                        .and_then(|it| match it.field(self.db, &field.name) {
-                            Some(field) => Some(field),
-                            None => {
-                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
-                                    expr: tgt_expr,
-                                    field: field_idx,
-                                });
-                                None
-                            }
-                        })
-                        .map_or(Ty::Unknown, |field| field.ty(self.db))
+                    let field_def = def_id.and_then(|it| match it.field(self.db, &field.name) {
+                        Some(field) => Some(field),
+                        None => {
+                            self.push_diagnostic(InferenceDiagnostic::NoSuchField {
+                                expr: tgt_expr,
+                                field: field_idx,
+                            });
+                            None
+                        }
+                    });
+                    if let Some(field_def) = field_def {
+                        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(),
-                    canonicalized.value.clone(),
+                    self.resolver.krate(),
+                    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 => {
-                        let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
-                        if let Some(derefed_ty) =
-                            autoderef::deref(self.db, &self.resolver, &canonicalized.value)
-                        {
-                            canonicalized.decanonicalize_ty(derefed_ty.value)
-                        } else {
-                            Ty::Unknown
+                    UnaryOp::Deref => match self.resolver.krate() {
+                        Some(krate) => {
+                            let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
+                            match autoderef::deref(
+                                self.db,
+                                krate,
+                                InEnvironment {
+                                    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) => {
-                        if let Some(trait_) = f.parent_trait(self.db) {
+                    CallableDef::FunctionId(f) => {
+                        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 =
-                matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
+            let expected_ty = matching_field
+                .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();