From 114a1b878e95c20490af574550ea0825b7a8f9d1 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 13 Sep 2019 00:34:52 +0300 Subject: rename AdtDef -> Adt --- crates/ra_hir/src/ty/infer.rs | 14 +++++++------- crates/ra_hir/src/ty/lower.rs | 24 +++++++++++------------- 2 files changed, 18 insertions(+), 20 deletions(-) (limited to 'crates/ra_hir/src/ty') diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index 725eec834..540a99b15 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -48,7 +48,7 @@ use crate::{ resolve::{Resolution, Resolver}, ty::infer::diagnostics::InferenceDiagnostic, type_ref::{Mutability, TypeRef}, - AdtDef, ConstData, DefWithBody, FnData, Function, HasBody, ImplItem, ModuleDef, Name, Path, + Adt, ConstData, DefWithBody, FnData, Function, HasBody, ImplItem, ModuleDef, Name, Path, StructField, }; @@ -668,7 +668,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { // FIXME remove the duplication between here and `Ty::from_path`? let substs = Ty::substs_from_path(self.db, resolver, path, def); match def { - TypableDef::AdtDef(AdtDef::Struct(s)) => { + TypableDef::Adt(Adt::Struct(s)) => { let ty = s.ty(self.db); let ty = self.insert_type_vars(ty.apply_substs(substs)); (ty, Some(s.into())) @@ -678,8 +678,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let ty = self.insert_type_vars(ty.apply_substs(substs)); (ty, Some(var.into())) } - TypableDef::AdtDef(AdtDef::Enum(_)) - | TypableDef::AdtDef(AdtDef::Union(_)) + TypableDef::Adt(Adt::Enum(_)) + | TypableDef::Adt(Adt::Union(_)) | TypableDef::TypeAlias(_) | TypableDef::Function(_) | TypableDef::Const(_) @@ -1185,7 +1185,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let i = name.to_string().parse::().ok(); i.and_then(|i| a_ty.parameters.0.get(i).cloned()) } - TypeCtor::Adt(AdtDef::Struct(s)) => s.field(self.db, name).map(|field| { + 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) }), @@ -1489,7 +1489,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { trait_.associated_type_by_name(self.db, &name::OUTPUT) } - fn resolve_boxed_box(&self) -> Option { + fn resolve_boxed_box(&self) -> Option { let boxed_box_path = Path { kind: PathKind::Abs, segments: vec![ @@ -1499,7 +1499,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { ], }; let struct_ = self.resolver.resolve_known_struct(self.db, &boxed_box_path)?; - Some(AdtDef::Struct(struct_)) + Some(Adt::Struct(struct_)) } } 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 = 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 + HasGenericParams) -> Ty { +fn type_for_adt(db: &impl HirDatabase, adt: impl Into + 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 for Option { fn from(def: ModuleDef) -> Option { 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(), -- cgit v1.2.3