From 566c8e321e89e5ff8996daa615cc47aea0012881 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 24 Jan 2019 18:56:38 +0300 Subject: migrate enums to new id --- crates/ra_hir/src/ty.rs | 90 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 59 insertions(+), 31 deletions(-) (limited to 'crates/ra_hir/src/ty.rs') diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index fc699a2ae..6a5f4fae6 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -166,27 +166,28 @@ impl Substs { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum AdtDef { Struct(Struct), - Def(DefId), // Enum + Enum(Enum), } impl From for AdtDef { - fn from(struct_: Struct) -> AdtDef { - AdtDef::Struct(struct_) + fn from(s: Struct) -> AdtDef { + AdtDef::Struct(s) } } -impl From for AdtDef { - fn from(def_id: DefId) -> AdtDef { - AdtDef::Def(def_id) +impl From for AdtDef { + fn from(e: Enum) -> AdtDef { + AdtDef::Enum(e) } } impl AdtDef { fn krate(self, db: &impl HirDatabase) -> Option { match self { - AdtDef::Struct(s) => s.module(db).krate(db), - AdtDef::Def(def_id) => def_id.krate(db), + AdtDef::Struct(s) => s.module(db), + AdtDef::Enum(e) => e.module(db), } + .krate(db) } } @@ -408,14 +409,16 @@ impl Ty { } // Resolve in module (in type namespace) - let resolved = match module.resolve_path(db, path).take_types() { - Some(ModuleDef::Def(r)) => r.into(), - Some(ModuleDef::Function(f)) => f.into(), - Some(ModuleDef::Struct(s)) => s.into(), - None | Some(ModuleDef::Module(_)) => return Ty::Unknown, + let typable: TypableDef = match module + .resolve_path(db, path) + .take_types() + .and_then(|it| it.into()) + { + None => return Ty::Unknown, + Some(it) => it, }; - let ty = db.type_for_def(resolved); - let substs = Ty::substs_from_path(db, module, impl_block, generics, path, resolved); + let ty = db.type_for_def(typable); + let substs = Ty::substs_from_path(db, module, impl_block, generics, path, typable); ty.apply_substs(substs) } @@ -438,9 +441,8 @@ impl Ty { let (def_generics, segment) = match resolved { TypableDef::Function(func) => (func.generic_params(db), last), TypableDef::Struct(s) => (s.generic_params(db), last), + TypableDef::Enum(e) => (e.generic_params(db), last), TypableDef::Def(def_id) => match def_id.resolve(db) { - Def::Struct(s) => (s.generic_params(db), last), - Def::Enum(e) => (e.generic_params(db), last), Def::Trait(t) => (t.generic_params(db), last), Def::EnumVariant(ev) => { // the generic args for an enum variant may be either specified @@ -680,7 +682,7 @@ fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { let generics = s.generic_params(db); Ty::Adt { - def_id: s.def_id().into(), + def_id: s.into(), name: s.name(db).unwrap_or_else(Name::missing), substs: make_substs(&generics), } @@ -696,6 +698,7 @@ pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> T pub enum TypableDef { Function(Function), Struct(Struct), + Enum(Enum), Def(DefId), } @@ -706,8 +709,14 @@ impl From for TypableDef { } impl From for TypableDef { - fn from(struct_: Struct) -> TypableDef { - TypableDef::Struct(struct_) + fn from(s: Struct) -> TypableDef { + TypableDef::Struct(s) + } +} + +impl From for TypableDef { + fn from(e: Enum) -> TypableDef { + TypableDef::Enum(e) } } @@ -717,10 +726,24 @@ impl From for TypableDef { } } +impl From for Option { + fn from(def: ModuleDef) -> Option { + let res = match def { + ModuleDef::Def(r) => r.into(), + ModuleDef::Function(f) => f.into(), + ModuleDef::Struct(s) => s.into(), + ModuleDef::Enum(e) => e.into(), + ModuleDef::Module(_) => return None, + }; + Some(res) + } +} + pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef) -> Ty { match def { TypableDef::Function(f) => type_for_fn(db, f), TypableDef::Struct(s) => type_for_struct(db, s), + TypableDef::Enum(e) => type_for_enum(db, e), TypableDef::Def(def_id) => match def_id.resolve(db) { Def::Enum(e) => type_for_enum(db, e), Def::EnumVariant(ev) => type_for_enum_variant(db, ev), @@ -1134,12 +1157,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { }; // resolve in module - let typable = match self.module.resolve_path(self.db, &path).take_values()? { - ModuleDef::Def(it) => it.into(), - ModuleDef::Function(func) => func.into(), - ModuleDef::Struct(s) => s.into(), - ModuleDef::Module(_) => return None, - }; + let typable: Option = self + .module + .resolve_path(self.db, &path) + .take_values()? + .into(); + let typable = typable?; let ty = self.db.type_for_def(typable); let ty = self.insert_type_vars(ty); Some(ty) @@ -1150,11 +1173,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { Some(path) => path, None => return (Ty::Unknown, None), }; - let def = match self.module.resolve_path(self.db, &path).take_types() { - Some(ModuleDef::Def(def_id)) => def_id.into(), - Some(ModuleDef::Function(func)) => func.into(), - Some(ModuleDef::Struct(s)) => s.into(), - None | Some(ModuleDef::Module(_)) => return (Ty::Unknown, None), + let typable: Option = self + .module + .resolve_path(self.db, &path) + .take_types() + .and_then(|it| it.into()); + let def = match typable { + None => return (Ty::Unknown, None), + Some(it) => it, }; // TODO remove the duplication between here and `Ty::from_path`? // TODO provide generics of function @@ -1182,6 +1208,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let ty = self.insert_type_vars(ty.apply_substs(substs)); (ty, Some(s.into())) } + TypableDef::Enum(_) => (Ty::Unknown, None), } } @@ -1300,6 +1327,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { ModuleDef::Def(it) => Some(it.into()), ModuleDef::Function(func) => Some(func.into()), ModuleDef::Struct(s) => Some(s.into()), + ModuleDef::Enum(e) => Some(e.into()), ModuleDef::Module(_) => None, }) .map_or(Ty::Unknown, |resolved| self.db.type_for_def(resolved)), -- cgit v1.2.3