Merge #2428

2428: Remove TypableDef r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

7 files changed, 105 insertions, 130 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index db9a8c9d1..59e4e5f36 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -22,11 +22,13 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use rustc_hash::FxHashMap;
 
 use hir_def::{
+    body::Body,
     data::{ConstData, FunctionData},
-    path::known,
+    expr::{BindingAnnotation, ExprId, PatId},
+    path::{known, Path},
     resolver::{HasResolver, Resolver, TypeNs},
     type_ref::{Mutability, TypeRef},
-    AdtId, AssocItemId, DefWithBodyId,
+    AdtId, AssocItemId, DefWithBodyId, FunctionId, StructFieldId, TypeAliasId, VariantId,
 };
 use hir_expand::{diagnostics::DiagnosticSink, name};
 use ra_arena::map::ArenaMap;
@@ -34,17 +36,12 @@ use ra_prof::profile;
 use test_utils::tested_by;
 
 use super::{
+    primitive::{FloatTy, IntTy},
     traits::{Guidance, Obligation, ProjectionPredicate, Solution},
     ApplicationTy, InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
     TypeWalk, Uncertain,
 };
-use crate::{
-    code_model::TypeAlias,
-    db::HirDatabase,
-    expr::{BindingAnnotation, Body, ExprId, PatId},
-    ty::infer::diagnostics::InferenceDiagnostic,
-    AssocItem, DefWithBody, FloatTy, Function, IntTy, Path, StructField, VariantDef,
-};
+use crate::{db::HirDatabase, ty::infer::diagnostics::InferenceDiagnostic};
 
 macro_rules! ty_app {
     ($ctor:pat, $param:pat) => {
@@ -62,15 +59,15 @@ mod pat;
 mod coerce;
 
 /// The entry point of type inference.
-pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
+pub fn infer_query(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
     let _p = profile("infer_query");
-    let resolver = DefWithBodyId::from(def).resolver(db);
+    let resolver = def.resolver(db);
     let mut ctx = InferenceContext::new(db, def, resolver);
 
-    match &def {
-        DefWithBody::Const(c) => ctx.collect_const(&db.const_data(c.id)),
-        DefWithBody::Function(f) => ctx.collect_fn(&db.function_data(f.id)),
-        DefWithBody::Static(s) => ctx.collect_const(&db.static_data(s.id)),
+    match def {
+        DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_data(c)),
+        DefWithBodyId::FunctionId(f) => ctx.collect_fn(&db.function_data(f)),
+        DefWithBodyId::StaticId(s) => ctx.collect_const(&db.static_data(s)),
     }
 
     ctx.infer_body();
@@ -121,15 +118,15 @@ pub struct TypeMismatch {
 #[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct InferenceResult {
     /// For each method call expr, records the function it resolves to.
-    method_resolutions: FxHashMap<ExprId, Function>,
+    method_resolutions: FxHashMap<ExprId, FunctionId>,
     /// For each field access expr, records the field it resolves to.
-    field_resolutions: FxHashMap<ExprId, StructField>,
+    field_resolutions: FxHashMap<ExprId, StructFieldId>,
     /// For each field in record literal, records the field it resolves to.
-    record_field_resolutions: FxHashMap<ExprId, StructField>,
+    record_field_resolutions: FxHashMap<ExprId, StructFieldId>,
     /// For each struct literal, records the variant it resolves to.
-    variant_resolutions: FxHashMap<ExprOrPatId, VariantDef>,
+    variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
     /// For each associated item record what it resolves to
-    assoc_resolutions: FxHashMap<ExprOrPatId, AssocItem>,
+    assoc_resolutions: FxHashMap<ExprOrPatId, AssocItemId>,
     diagnostics: Vec<InferenceDiagnostic>,
     pub(super) type_of_expr: ArenaMap<ExprId, Ty>,
     pub(super) type_of_pat: ArenaMap<PatId, Ty>,
@@ -137,25 +134,25 @@ pub struct InferenceResult {
 }
 
 impl InferenceResult {
-    pub fn method_resolution(&self, expr: ExprId) -> Option<Function> {
+    pub fn method_resolution(&self, expr: ExprId) -> Option<FunctionId> {
         self.method_resolutions.get(&expr).copied()
     }
-    pub fn field_resolution(&self, expr: ExprId) -> Option<StructField> {
+    pub fn field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
         self.field_resolutions.get(&expr).copied()
     }
-    pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructField> {
+    pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
         self.record_field_resolutions.get(&expr).copied()
     }
-    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantDef> {
+    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> {
         self.variant_resolutions.get(&id.into()).copied()
     }
-    pub fn variant_resolution_for_pat(&self, id: PatId) -> Option<VariantDef> {
+    pub fn variant_resolution_for_pat(&self, id: PatId) -> Option<VariantId> {
         self.variant_resolutions.get(&id.into()).copied()
     }
-    pub fn assoc_resolutions_for_expr(&self, id: ExprId) -> Option<AssocItem> {
+    pub fn assoc_resolutions_for_expr(&self, id: ExprId) -> Option<AssocItemId> {
         self.assoc_resolutions.get(&id.into()).copied()
     }
-    pub fn assoc_resolutions_for_pat(&self, id: PatId) -> Option<AssocItem> {
+    pub fn assoc_resolutions_for_pat(&self, id: PatId) -> Option<AssocItemId> {
         self.assoc_resolutions.get(&id.into()).copied()
     }
     pub fn type_mismatch_for_expr(&self, expr: ExprId) -> Option<&TypeMismatch> {
@@ -164,7 +161,7 @@ impl InferenceResult {
     pub(crate) fn add_diagnostics(
         &self,
         db: &impl HirDatabase,
-        owner: Function,
+        owner: FunctionId,
         sink: &mut DiagnosticSink,
     ) {
         self.diagnostics.iter().for_each(|it| it.add_to(db, owner, sink))
@@ -191,7 +188,7 @@ impl Index<PatId> for InferenceResult {
 #[derive(Clone, Debug)]
 struct InferenceContext<'a, D: HirDatabase> {
     db: &'a D,
-    owner: DefWithBody,
+    owner: DefWithBodyId,
     body: Arc<Body>,
     resolver: Resolver,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
@@ -209,7 +206,7 @@ struct InferenceContext<'a, D: HirDatabase> {
 }
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
-    fn new(db: &'a D, owner: DefWithBody, resolver: Resolver) -> Self {
+    fn new(db: &'a D, owner: DefWithBodyId, resolver: Resolver) -> Self {
         InferenceContext {
             result: InferenceResult::default(),
             var_unification_table: InPlaceUnificationTable::new(),
@@ -243,15 +240,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.result.type_of_expr.insert(expr, ty);
     }
 
-    fn write_method_resolution(&mut self, expr: ExprId, func: Function) {
+    fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId) {
         self.result.method_resolutions.insert(expr, func);
     }
 
-    fn write_field_resolution(&mut self, expr: ExprId, field: StructField) {
+    fn write_field_resolution(&mut self, expr: ExprId, field: StructFieldId) {
         self.result.field_resolutions.insert(expr, field);
     }
 
-    fn write_variant_resolution(&mut self, id: ExprOrPatId, variant: VariantDef) {
+    fn write_variant_resolution(&mut self, id: ExprOrPatId, variant: VariantId) {
         self.result.variant_resolutions.insert(id, variant);
     }
 
@@ -514,7 +511,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         })
     }
 
-    fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantDef>) {
+    fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantId>) {
         let path = match path {
             Some(path) => path,
             None => return (Ty::Unknown, None),
@@ -527,13 +524,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let substs = Ty::substs_from_path(self.db, resolver, path, strukt.into());
                 let ty = self.db.ty(strukt.into());
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
-                (ty, Some(VariantDef::Struct(strukt.into())))
+                (ty, Some(strukt.into()))
             }
             Some(TypeNs::EnumVariantId(var)) => {
                 let substs = Ty::substs_from_path(self.db, resolver, path, var.into());
                 let ty = self.db.ty(var.parent.into());
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
-                (ty, Some(VariantDef::EnumVariant(var.into())))
+                (ty, Some(var.into()))
             }
             Some(_) | None => (Ty::Unknown, None),
         }
@@ -557,22 +554,22 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.infer_expr(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
     }
 
-    fn resolve_into_iter_item(&self) -> Option<TypeAlias> {
+    fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
         let path = known::std_iter_into_iterator();
         let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::ITEM_TYPE).map(TypeAlias::from)
+        self.db.trait_data(trait_).associated_type_by_name(&name::ITEM_TYPE)
     }
 
-    fn resolve_ops_try_ok(&self) -> Option<TypeAlias> {
+    fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {
         let path = known::std_ops_try();
         let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::OK_TYPE).map(TypeAlias::from)
+        self.db.trait_data(trait_).associated_type_by_name(&name::OK_TYPE)
     }
 
-    fn resolve_future_future_output(&self) -> Option<TypeAlias> {
+    fn resolve_future_future_output(&self) -> Option<TypeAliasId> {
         let path = known::std_future_future();
         let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE).map(TypeAlias::from)
+        self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE)
     }
 
     fn resolve_boxed_box(&self) -> Option<AdtId> {
@@ -696,9 +693,10 @@ impl Expectation {
 }
 
 mod diagnostics {
+    use hir_def::{expr::ExprId, FunctionId, HasSource, Lookup};
     use hir_expand::diagnostics::DiagnosticSink;
 
-    use crate::{db::HirDatabase, diagnostics::NoSuchField, expr::ExprId, Function, HasSource};
+    use crate::{db::HirDatabase, diagnostics::NoSuchField};
 
     #[derive(Debug, PartialEq, Eq, Clone)]
     pub(super) enum InferenceDiagnostic {
@@ -709,13 +707,14 @@ mod diagnostics {
         pub(super) fn add_to(
             &self,
             db: &impl HirDatabase,
-            owner: Function,
+            owner: FunctionId,
             sink: &mut DiagnosticSink,
         ) {
             match self {
                 InferenceDiagnostic::NoSuchField { expr, field } => {
-                    let file = owner.source(db).file_id;
-                    let field = owner.body_source_map(db).field_syntax(*expr, *field);
+                    let file = owner.lookup(db).source(db).file_id;
+                    let (_, source_map) = db.body_with_source_map(owner.into());
+                    let field = source_map.field_syntax(*expr, *field);
                     sink.push(NoSuchField { file, field })
                 }
             }
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs
index 57f845dfa..f9ededa23 100644
--- a/crates/ra_hir/src/ty/infer/expr.rs
+++ b/crates/ra_hir/src/ty/infer/expr.rs
@@ -16,9 +16,9 @@ use hir_expand::name::{self, Name};
 use crate::{
     db::HirDatabase,
     ty::{
-        autoderef, method_resolution, op, traits::InEnvironment, CallableDef, InferTy, IntTy,
-        Mutability, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
-        TypeWalk, Uncertain,
+        autoderef, method_resolution, op, traits::InEnvironment, utils::variant_data, CallableDef,
+        InferTy, IntTy, Mutability, Obligation, ProjectionPredicate, ProjectionTy, Substs,
+        TraitRef, Ty, TypeCtor, TypeWalk, Uncertain,
     },
 };
 
@@ -100,7 +100,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         let projection = ProjectionPredicate {
                             ty: pat_ty.clone(),
                             projection_ty: ProjectionTy {
-                                associated_ty: into_iter_item_alias.id,
+                                associated_ty: into_iter_item_alias,
                                 parameters: Substs::single(iterable_ty),
                             },
                         };
@@ -218,22 +218,26 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 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();
+                let variant_data = def_id.map(|it| variant_data(self.db, it));
                 for (field_idx, field) in fields.iter().enumerate() {
-                    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
-                        }
-                    });
+                    let field_def =
+                        variant_data.as_ref().and_then(|it| match it.field(&field.name) {
+                            Some(local_id) => {
+                                Some(StructFieldId { parent: def_id.unwrap(), local_id })
+                            }
+                            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())
+                        .map_or(Ty::Unknown, |it| field_types[it.local_id].clone())
                         .subst(&substs);
                     self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
                 }
@@ -262,7 +266,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             self.db.struct_data(s).variant_data.field(name).map(|local_id| {
                                 let field = StructFieldId { parent: s.into(), local_id }.into();
                                 self.write_field_resolution(tgt_expr, field);
-                                self.db.field_types(s.into())[field.id]
+                                self.db.field_types(s.into())[field.local_id]
                                     .clone()
                                     .subst(&a_ty.parameters)
                             })
@@ -285,7 +289,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         let projection = ProjectionPredicate {
                             ty: ty.clone(),
                             projection_ty: ProjectionTy {
-                                associated_ty: future_future_output_alias.id,
+                                associated_ty: future_future_output_alias,
                                 parameters: Substs::single(inner_ty),
                             },
                         };
@@ -304,7 +308,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                         let projection = ProjectionPredicate {
                             ty: ty.clone(),
                             projection_ty: ProjectionTy {
-                                associated_ty: ops_try_ok_alias.id,
+                                associated_ty: ops_try_ok_alias,
                                 parameters: Substs::single(inner_ty),
                             },
                         };
@@ -557,7 +561,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Some((ty, func)) => {
                 let ty = canonicalized_receiver.decanonicalize_ty(ty);
                 self.write_method_resolution(tgt_expr, func);
-                (ty, self.db.value_ty(func.id.into()), Some(self.db.generic_params(func.id.into())))
+                (ty, self.db.value_ty(func.into()), Some(self.db.generic_params(func.into())))
             }
             None => (receiver_ty, Ty::Unknown, None),
         };
diff --git a/crates/ra_hir/src/ty/infer/pat.rs b/crates/ra_hir/src/ty/infer/pat.rs
index 6dbf03eb2..a14774607 100644
--- a/crates/ra_hir/src/ty/infer/pat.rs
+++ b/crates/ra_hir/src/ty/infer/pat.rs
@@ -14,7 +14,7 @@ use test_utils::tested_by;
 use super::{BindingMode, InferenceContext};
 use crate::{
     db::HirDatabase,
-    ty::{Substs, Ty, TypeCtor, TypeWalk},
+    ty::{utils::variant_data, Substs, Ty, TypeCtor, TypeWalk},
 };
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
@@ -26,16 +26,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         default_bm: BindingMode,
     ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
-
+        let var_data = def.map(|it| variant_data(self.db, it));
         self.unify(&ty, expected);
 
         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_tys[field.id].clone())
+            let expected_ty = var_data
+                .as_ref()
+                .and_then(|d| d.field(&Name::new_tuple_field(i)))
+                .map_or(Ty::Unknown, |field| field_tys[field].clone())
                 .subst(&substs);
             let expected_ty = self.normalize_associated_types_in(expected_ty);
             self.infer_pat(subpat, &expected_ty, default_bm);
@@ -53,6 +55,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         id: PatId,
     ) -> Ty {
         let (ty, def) = self.resolve_variant(path);
+        let var_data = def.map(|it| variant_data(self.db, it));
         if let Some(variant) = def {
             self.write_variant_resolution(id.into(), variant);
         }
@@ -63,10 +66,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
 
         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_tys[field.id].clone())
-                .subst(&substs);
+            let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
+            let expected_ty =
+                matching_field.map_or(Ty::Unknown, |field| field_tys[field].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 1c0f71adc..5dce2f342 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -11,7 +11,7 @@ use std::sync::Arc;
 use hir_def::{
     builtin_type::BuiltinType,
     generics::WherePredicate,
-    path::{GenericArg, PathSegment},
+    path::{GenericArg, Path, PathSegment},
     resolver::{HasResolver, Resolver, TypeNs},
     type_ref::{TypeBound, TypeRef},
     AdtId, AstItemDef, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule,
@@ -28,11 +28,10 @@ use crate::{
     db::HirDatabase,
     ty::{
         primitive::{FloatTy, IntTy},
-        utils::{all_super_traits, associated_type_by_name_including_super_traits},
+        utils::{all_super_traits, associated_type_by_name_including_super_traits, variant_data},
     },
     util::make_mut_slice,
-    Adt, Const, Enum, EnumVariant, Function, ImplBlock, ModuleDef, Path, Static, Struct, Trait,
-    TypeAlias, Union,
+    ImplBlock, Trait,
 };
 
 impl Ty {
@@ -514,13 +513,11 @@ pub(crate) fn field_types_query(
     db: &impl HirDatabase,
     variant_id: VariantId,
 ) -> Arc<ArenaMap<LocalStructFieldId, Ty>> {
-    let (resolver, var_data) = match variant_id {
-        VariantId::StructId(it) => (it.resolver(db), db.struct_data(it).variant_data.clone()),
-        VariantId::UnionId(it) => (it.resolver(db), db.union_data(it).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 = variant_data(db, variant_id);
+    let resolver = match variant_id {
+        VariantId::StructId(it) => it.resolver(db),
+        VariantId::UnionId(it) => it.resolver(db),
+        VariantId::EnumVariantId(it) => it.parent.resolver(db),
     };
     let mut res = ArenaMap::default();
     for (field_id, field_data) in var_data.fields().iter() {
@@ -696,42 +693,6 @@ fn type_for_type_alias(db: &impl HirDatabase, t: TypeAliasId) -> Ty {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum TypableDef {
-    Function(Function),
-    Adt(Adt),
-    EnumVariant(EnumVariant),
-    TypeAlias(TypeAlias),
-    Const(Const),
-    Static(Static),
-    BuiltinType(BuiltinType),
-}
-impl_froms!(
-    TypableDef: Function,
-    Adt(Struct, Enum, Union),
-    EnumVariant,
-    TypeAlias,
-    Const,
-    Static,
-    BuiltinType
-);
-
-impl From<ModuleDef> for Option<TypableDef> {
-    fn from(def: ModuleDef) -> Option<TypableDef> {
-        let res = match def {
-            ModuleDef::Function(f) => f.into(),
-            ModuleDef::Adt(adt) => adt.into(),
-            ModuleDef::EnumVariant(v) => v.into(),
-            ModuleDef::TypeAlias(t) => t.into(),
-            ModuleDef::Const(v) => v.into(),
-            ModuleDef::Static(v) => v.into(),
-            ModuleDef::BuiltinType(t) => t.into(),
-            ModuleDef::Module(_) | ModuleDef::Trait(_) => return None,
-        };
-        Some(res)
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum CallableDef {
     FunctionId(FunctionId),
     StructId(StructId),
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 02e81fb34..5cc249855 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use arrayvec::ArrayVec;
 use hir_def::{
     lang_item::LangItemTarget, resolver::HasResolver, resolver::Resolver, type_ref::Mutability,
-    AssocItemId, AstItemDef, HasModule, ImplId, TraitId,
+    AssocItemId, AstItemDef, FunctionId, HasModule, ImplId, TraitId,
 };
 use hir_expand::name::Name;
 use ra_db::CrateId;
@@ -18,7 +18,6 @@ use crate::{
     db::HirDatabase,
     ty::primitive::{FloatBitness, Uncertain},
     ty::{utils::all_super_traits, Ty, TypeCtor},
-    Function,
 };
 
 use super::{autoderef, Canonical, InEnvironment, TraitEnvironment, TraitRef};
@@ -154,10 +153,10 @@ pub(crate) fn lookup_method(
     db: &impl HirDatabase,
     name: &Name,
     resolver: &Resolver,
-) -> Option<(Ty, Function)> {
+) -> Option<(Ty, FunctionId)> {
     iterate_method_candidates(ty, db, resolver, Some(name), LookupMode::MethodCall, |ty, f| match f
     {
-        AssocItemId::FunctionId(f) => Some((ty.clone(), f.into())),
+        AssocItemId::FunctionId(f) => Some((ty.clone(), f)),
         _ => None,
     })
 }
diff --git a/crates/ra_hir/src/ty/op.rs b/crates/ra_hir/src/ty/op.rs
index bcfa3a6a2..cc6e244f4 100644
--- a/crates/ra_hir/src/ty/op.rs
+++ b/crates/ra_hir/src/ty/op.rs
@@ -1,10 +1,8 @@
 //! FIXME: write short doc here
+use hir_def::expr::{BinaryOp, CmpOp};
 
 use super::{InferTy, Ty, TypeCtor};
-use crate::{
-    expr::{BinaryOp, CmpOp},
-    ty::ApplicationTy,
-};
+use crate::ty::ApplicationTy;
 
 pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
     match op {
diff --git a/crates/ra_hir/src/ty/utils.rs b/crates/ra_hir/src/ty/utils.rs
index 80ffceb4b..f82e6ac9b 100644
--- a/crates/ra_hir/src/ty/utils.rs
+++ b/crates/ra_hir/src/ty/utils.rs
@@ -1,11 +1,13 @@
 //! Helper functions for working with def, which don't need to be a separate
 //! query, but can't be computed directly from `*Data` (ie, which need a `db`).
+use std::sync::Arc;
 
 use hir_def::{
+    adt::VariantData,
     db::DefDatabase,
     resolver::{HasResolver, TypeNs},
     type_ref::TypeRef,
-    TraitId, TypeAliasId,
+    TraitId, TypeAliasId, VariantId,
 };
 use hir_expand::name::{self, Name};
 
@@ -61,3 +63,13 @@ pub(super) fn associated_type_by_name_including_super_traits(
         .into_iter()
         .find_map(|t| db.trait_data(t).associated_type_by_name(name))
 }
+
+pub(super) fn variant_data(db: &impl DefDatabase, var: VariantId) -> Arc<VariantData> {
+    match var {
+        VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),
+        VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),
+        VariantId::EnumVariantId(it) => {
+            db.enum_data(it.parent).variants[it.local_id].variant_data.clone()
+        }
+    }
+}