1 files changed, 11 insertions, 13 deletions

diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 105c893f0..946e9e9fb 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -20,7 +20,7 @@ use crate::{
     nameres::Namespace,
     path::{GenericArg, PathSegment},
     resolve::{Resolution, Resolver},
-    ty::AdtDef,
+    ty::Adt,
     type_ref::{TypeBound, TypeRef},
     BuiltinType, Const, Enum, EnumVariant, Function, ModuleDef, Path, Static, Struct, StructField,
     Trait, TypeAlias, Union,
@@ -172,7 +172,7 @@ impl Ty {
     ) -> Substs {
         let def_generic: Option<GenericDef> = match resolved {
             TypableDef::Function(func) => Some(func.into()),
-            TypableDef::AdtDef(adt) => Some(adt.into()),
+            TypableDef::Adt(adt) => Some(adt.into()),
             TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
             TypableDef::TypeAlias(t) => Some(t.into()),
             TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::BuiltinType(_) => None,
@@ -191,7 +191,7 @@ impl Ty {
         let last = path.segments.last().expect("path should have at least one segment");
         let segment = match resolved {
             TypableDef::Function(_)
-            | TypableDef::AdtDef(_)
+            | TypableDef::Adt(_)
             | TypableDef::Const(_)
             | TypableDef::Static(_)
             | TypableDef::TypeAlias(_)
@@ -406,10 +406,8 @@ fn assoc_type_bindings_from_type_bound<'a>(
 pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty {
     match (def, ns) {
         (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f),
-        (TypableDef::AdtDef(AdtDef::Struct(s)), Namespace::Values) => {
-            type_for_struct_constructor(db, s)
-        }
-        (TypableDef::AdtDef(adt), Namespace::Types) => type_for_adt(db, adt),
+        (TypableDef::Adt(Adt::Struct(s)), Namespace::Values) => type_for_struct_constructor(db, s),
+        (TypableDef::Adt(adt), Namespace::Types) => type_for_adt(db, adt),
         (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
         (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t),
         (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c),
@@ -418,8 +416,8 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
 
         // 'error' cases:
         (TypableDef::Function(_), Namespace::Types) => Ty::Unknown,
-        (TypableDef::AdtDef(AdtDef::Union(_)), Namespace::Values) => Ty::Unknown,
-        (TypableDef::AdtDef(AdtDef::Enum(_)), Namespace::Values) => Ty::Unknown,
+        (TypableDef::Adt(Adt::Union(_)), Namespace::Values) => Ty::Unknown,
+        (TypableDef::Adt(Adt::Enum(_)), Namespace::Values) => Ty::Unknown,
         (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown,
         (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown,
         (TypableDef::Const(_), Namespace::Types) => Ty::Unknown,
@@ -587,7 +585,7 @@ fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) ->
     Ty::apply(TypeCtor::FnDef(def.into()), substs)
 }
 
-fn type_for_adt(db: &impl HirDatabase, adt: impl Into<AdtDef> + HasGenericParams) -> Ty {
+fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt> + HasGenericParams) -> Ty {
     let generics = adt.generic_params(db);
     Ty::apply(TypeCtor::Adt(adt.into()), Substs::identity(&generics))
 }
@@ -604,7 +602,7 @@ fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum TypableDef {
     Function(Function),
-    AdtDef(AdtDef),
+    Adt(Adt),
     EnumVariant(EnumVariant),
     TypeAlias(TypeAlias),
     Const(Const),
@@ -613,7 +611,7 @@ pub enum TypableDef {
 }
 impl_froms!(
     TypableDef: Function,
-    AdtDef(Struct, Enum, Union),
+    Adt(Struct, Enum, Union),
     EnumVariant,
     TypeAlias,
     Const,
@@ -625,7 +623,7 @@ impl From<ModuleDef> for Option<TypableDef> {
     fn from(def: ModuleDef) -> Option<TypableDef> {
         let res = match def {
             ModuleDef::Function(f) => f.into(),
-            ModuleDef::AdtDef(adt) => adt.into(),
+            ModuleDef::Adt(adt) => adt.into(),
             ModuleDef::EnumVariant(v) => v.into(),
             ModuleDef::TypeAlias(t) => t.into(),
             ModuleDef::Const(v) => v.into(),