1 files changed, 51 insertions, 30 deletions

diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index ac570075f..194e55819 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -5,6 +5,7 @@ use std::sync::Arc;
 
 use hir_def::{
     builtin_type::Signedness,
+    generics::GenericParams,
     path::{GenericArg, GenericArgs},
     resolver::resolver_for_expr,
 };
@@ -13,11 +14,10 @@ use hir_expand::name;
 use crate::{
     db::HirDatabase,
     expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
-    generics::{GenericParams, HasGenericParams},
     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 +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
-                        .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 +245,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 +258,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 +340,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 {
@@ -534,7 +553,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 (
                     ty,
                     self.db.type_for_def(func.into(), Namespace::Values),
-                    Some(func.generic_params(self.db)),
+                    Some(self.db.generic_params(func.id.into())),
                 )
             }
             None => (receiver_ty, Ty::Unknown, None),
@@ -645,7 +664,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         if let Some(trait_) = f.parent_trait(self.db) {
                             // construct a TraitDef
                             let substs = a_ty.parameters.prefix(
-                                trait_.generic_params(self.db).count_params_including_parent(),
+                                self.db
+                                    .generic_params(trait_.id.into())
+                                    .count_params_including_parent(),
                             );
                             self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
                         }