From d571d26955148befd6986008a5112fff3a901c43 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Wed, 30 Jan 2019 22:41:44 +0100 Subject: Make the Resolution variants tuple variants --- crates/ra_hir/src/generics.rs | 1 + crates/ra_hir/src/impl_block.rs | 7 +++---- crates/ra_hir/src/resolve.rs | 30 +++++++++++------------------- crates/ra_hir/src/ty.rs | 18 +++++++++--------- 4 files changed, 24 insertions(+), 32 deletions(-) (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs index b0bd735bd..a82205f0b 100644 --- a/crates/ra_hir/src/generics.rs +++ b/crates/ra_hir/src/generics.rs @@ -12,6 +12,7 @@ use crate::{db::PersistentHirDatabase, Name, AsName, Function, Struct, Enum, Tra /// Data about a generic parameter (to a function, struct, impl, ...). #[derive(Clone, PartialEq, Eq, Debug)] pub struct GenericParam { + // TODO: give generic params proper IDs pub(crate) idx: u32, pub(crate) name: Name, } diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index a3908048b..738c58fbe 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -90,9 +90,8 @@ impl ImplBlock { pub fn target_trait(&self, db: &impl HirDatabase) -> Option { if let Some(TypeRef::Path(path)) = self.target_trait_ref() { let resolver = self.resolver(db); - if let Some(Resolution::Def { - def: ModuleDef::Trait(tr), - }) = resolver.resolve_path(db, path).take_types() + if let Some(Resolution::Def(ModuleDef::Trait(tr))) = + resolver.resolve_path(db, path).take_types() { return Some(tr); } @@ -106,7 +105,7 @@ impl ImplBlock { pub fn resolver(&self, db: &impl HirDatabase) -> Resolver { let r = self.module().resolver(db); - // FIXME: add generics + // TODO: add generics let r = r.push_impl_block_scope(self.clone()); r } diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs index 3e0af3a43..7929e8b7c 100644 --- a/crates/ra_hir/src/resolve.rs +++ b/crates/ra_hir/src/resolve.rs @@ -48,17 +48,11 @@ pub(crate) enum Scope { pub enum Resolution { // FIXME make these tuple variants /// An item - Def { - def: ModuleDef, - }, + Def(ModuleDef), /// A local binding (only value namespace) - LocalBinding { - pat: PatId, - }, + LocalBinding(PatId), /// A generic parameter - GenericParam { - idx: u32, - }, + GenericParam(u32), SelfType(ImplBlock), } @@ -85,7 +79,7 @@ impl Resolver { _ => return PerNs::none(), }; let module_res = item_map.resolve_path(db, module, path); - module_res.map(|def| Resolution::Def { def }) + module_res.map(|def| Resolution::Def(def)) } } @@ -157,18 +151,16 @@ impl Scope { match self { Scope::ModuleScope(m) => { if let Some(KnownName::SelfParam) = name.as_known_name() { - PerNs::types(Resolution::Def { - def: m.module.into(), - }) + PerNs::types(Resolution::Def(m.module.into())) } else { match m.item_map[m.module.module_id].get(name) { - Some(res) => res.def.map(|def| Resolution::Def { def }), + Some(res) => res.def.map(Resolution::Def), None => PerNs::none(), } } } Scope::GenericParams(gp) => match gp.find_by_name(name) { - Some(gp) => PerNs::types(Resolution::GenericParam { idx: gp.idx }), + Some(gp) => PerNs::types(Resolution::GenericParam(gp.idx)), None => PerNs::none(), }, Scope::ImplBlockScope(i) => { @@ -185,7 +177,7 @@ impl Scope { .iter() .find(|entry| entry.name() == name); match entry { - Some(e) => PerNs::values(Resolution::LocalBinding { pat: e.pat() }), + Some(e) => PerNs::values(Resolution::LocalBinding(e.pat())), None => PerNs::none(), } } @@ -205,14 +197,14 @@ impl Scope { m.item_map[m.module.module_id] .entries() .for_each(|(name, res)| { - f(name.clone(), res.def.map(|def| Resolution::Def { def })); + f(name.clone(), res.def.map(Resolution::Def)); }) } Scope::GenericParams(gp) => { for param in &gp.params { f( param.name.clone(), - PerNs::types(Resolution::GenericParam { idx: param.idx }), + PerNs::types(Resolution::GenericParam(param.idx)), ) } } @@ -226,7 +218,7 @@ impl Scope { e.expr_scopes.entries(e.scope_id).iter().for_each(|e| { f( e.name().clone(), - PerNs::values(Resolution::LocalBinding { pat: e.pat() }), + PerNs::values(Resolution::LocalBinding(e.pat())), ); }); } diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index d9c62f84c..cc5afad75 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -368,12 +368,12 @@ impl Ty { let resolution = resolver.resolve_path(db, path).take_types(); let def = match resolution { - Some(Resolution::Def { def, .. }) => def, - Some(Resolution::LocalBinding { .. }) => { + Some(Resolution::Def(def)) => def, + Some(Resolution::LocalBinding(..)) => { // this should never happen panic!("path resolved to local binding in type ns"); } - Some(Resolution::GenericParam { idx }) => { + Some(Resolution::GenericParam(idx)) => { return Ty::Param { idx, // TODO: maybe return name in resolution? @@ -1107,7 +1107,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path) -> Option { let resolved = resolver.resolve_path(self.db, &path).take_values()?; match resolved { - Resolution::Def { def, .. } => { + Resolution::Def(def) => { let typable: Option = def.into(); let typable = typable?; let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable); @@ -1115,12 +1115,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let ty = self.insert_type_vars(ty); Some(ty) } - Resolution::LocalBinding { pat } => { + Resolution::LocalBinding(pat) => { let ty = self.type_of_pat.get(pat)?; let ty = self.resolve_ty_as_possible(&mut vec![], ty.clone()); Some(ty) } - Resolution::GenericParam { .. } => { + Resolution::GenericParam(..) => { // generic params can't refer to values... yet None } @@ -1138,13 +1138,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { }; let resolver = &self.resolver; let typable: Option = match resolver.resolve_path(self.db, &path).take_types() { - Some(Resolution::Def { def, .. }) => def.into(), - Some(Resolution::LocalBinding { .. }) => { + Some(Resolution::Def(def)) => def.into(), + Some(Resolution::LocalBinding(..)) => { // this cannot happen log::error!("path resolved to local binding in type ns"); return (Ty::Unknown, None); } - Some(Resolution::GenericParam { .. }) => { + Some(Resolution::GenericParam(..)) => { // generic params can't be used in struct literals return (Ty::Unknown, None); } -- cgit v1.2.3