From a040fde3ae5e339199237f24a7461812e74475bf Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Mon, 16 Sep 2019 22:01:13 +0200 Subject: [PATCH] Remove TraitItem and ImplItem in favor of AssocItem --- crates/ra_cli/src/analysis_stats.rs | 4 +-- crates/ra_hir/src/code_model.rs | 33 +++++-------------- crates/ra_hir/src/impl_block.rs | 28 ++++------------ crates/ra_hir/src/lib.rs | 2 +- crates/ra_hir/src/traits.rs | 23 +++---------- crates/ra_hir/src/ty/infer.rs | 26 +++++++-------- crates/ra_hir/src/ty/method_resolution.rs | 11 +++---- crates/ra_hir/src/ty/traits/chalk.rs | 6 ++-- .../src/completion/complete_path.rs | 6 ++-- 9 files changed, 46 insertions(+), 93 deletions(-) diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs index 8f4ce42da5d..6b1e44a2c5f 100644 --- a/crates/ra_cli/src/analysis_stats.rs +++ b/crates/ra_cli/src/analysis_stats.rs @@ -1,7 +1,7 @@ use std::{collections::HashSet, fmt::Write, path::Path, time::Instant}; use ra_db::SourceDatabase; -use ra_hir::{Crate, HasBodySource, HasSource, HirDisplay, ImplItem, ModuleDef, Ty, TypeWalk}; +use ra_hir::{AssocItem, Crate, HasBodySource, HasSource, HirDisplay, ModuleDef, Ty, TypeWalk}; use ra_syntax::AstNode; use crate::{Result, Verbosity}; @@ -47,7 +47,7 @@ pub fn run( for impl_block in module.impl_blocks(db) { for item in impl_block.items(db) { num_decls += 1; - if let ImplItem::Method(f) = item { + if let AssocItem::Function(f) = item { funcs.push(f); } } diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 892208c1a98..706d24c3250 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -23,7 +23,7 @@ use crate::{ }, nameres::{CrateModuleId, ImportId, ModuleScope, Namespace}, resolve::{Resolver, TypeNs}, - traits::{TraitData, TraitItem}, + traits::TraitData, ty::{ primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness}, InferenceResult, TraitRef, @@ -269,7 +269,7 @@ impl Module { for impl_block in self.impl_blocks(db) { for item in impl_block.items(db) { - if let crate::ImplItem::Method(f) = item { + if let AssocItem::Function(f) = item { f.diagnostics(db, sink); } } @@ -853,7 +853,7 @@ impl Trait { self.trait_data(db).name().clone() } - pub fn items(self, db: &impl DefDatabase) -> Vec { + pub fn items(self, db: &impl DefDatabase) -> Vec { self.trait_data(db).items().to_vec() } @@ -906,7 +906,7 @@ impl Trait { .items() .iter() .filter_map(|item| match item { - TraitItem::TypeAlias(t) => Some(*t), + AssocItem::TypeAlias(t) => Some(*t), _ => None, }) .find(|t| &t.name(db) == name) @@ -1030,23 +1030,8 @@ pub enum AssocItem { Const(Const), TypeAlias(TypeAlias), } - -impl From for AssocItem { - fn from(t: TraitItem) -> Self { - match t { - TraitItem::Function(f) => AssocItem::Function(f), - TraitItem::Const(c) => AssocItem::Const(c), - TraitItem::TypeAlias(t) => AssocItem::TypeAlias(t), - } - } -} - -impl From for AssocItem { - fn from(i: crate::ImplItem) -> Self { - match i { - crate::ImplItem::Method(f) => AssocItem::Function(f), - crate::ImplItem::Const(c) => AssocItem::Const(c), - crate::ImplItem::TypeAlias(t) => AssocItem::TypeAlias(t), - } - } -} +// FIXME: not every function, ... is actually an assoc item. maybe we should make +// sure that you can only turn actual assoc items into AssocItems. This would +// require not implementing From, and instead having some checked way of +// casting them, and somehow making the constructors private, which would be annoying. +impl_froms!(AssocItem: Function, Const, TypeAlias); diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index d26a024ed55..c463d351cf1 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -15,7 +15,7 @@ use crate::{ resolve::Resolver, ty::Ty, type_ref::TypeRef, - Const, Function, HasSource, HirFileId, Source, TraitRef, TypeAlias, + AssocItem, Const, Function, HasSource, HirFileId, Source, TraitRef, TypeAlias, }; #[derive(Debug, Default, PartialEq, Eq)] @@ -56,7 +56,7 @@ impl HasSource for ImplBlock { impl ImplBlock { pub(crate) fn containing( module_impl_blocks: Arc, - item: ImplItem, + item: AssocItem, ) -> Option { let impl_id = *module_impl_blocks.impls_by_def.get(&item)?; Some(ImplBlock { module: module_impl_blocks.module, impl_id }) @@ -91,7 +91,7 @@ impl ImplBlock { TraitRef::from_hir(db, &self.resolver(db), &self.target_trait(db)?, Some(target_ty)) } - pub fn items(&self, db: &impl DefDatabase) -> Vec { + pub fn items(&self, db: &impl DefDatabase) -> Vec { db.impls_in_module(self.module).impls[self.impl_id].items().to_vec() } @@ -113,7 +113,7 @@ impl ImplBlock { pub struct ImplData { target_trait: Option, target_type: TypeRef, - items: Vec, + items: Vec, negative: bool, } @@ -151,27 +151,11 @@ impl ImplData { &self.target_type } - pub fn items(&self) -> &[ImplItem] { + pub fn items(&self) -> &[AssocItem] { &self.items } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -//FIXME: rename to ImplDef? -pub enum ImplItem { - Method(Function), - Const(Const), - TypeAlias(TypeAlias), - // Existential -} -impl_froms!(ImplItem: Const, TypeAlias); - -impl From for ImplItem { - fn from(func: Function) -> ImplItem { - ImplItem::Method(func) - } -} - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ImplId(pub RawId); impl_arena_id!(ImplId); @@ -185,7 +169,7 @@ impl_arena_id!(ImplId); pub struct ModuleImplBlocks { pub(crate) module: Module, pub(crate) impls: Arena, - impls_by_def: FxHashMap, + impls_by_def: FxHashMap, } impl ModuleImplBlocks { diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index db82a463c6e..e7a576aa0a7 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -69,7 +69,7 @@ pub use self::{ expr::ExprScopes, generics::{GenericParam, GenericParams, HasGenericParams}, ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, - impl_block::{ImplBlock, ImplItem}, + impl_block::ImplBlock, name::Name, nameres::{ImportId, Namespace, PerNs}, path::{Path, PathKind}, diff --git a/crates/ra_hir/src/traits.rs b/crates/ra_hir/src/traits.rs index 4c2f7980ddb..e39511518d1 100644 --- a/crates/ra_hir/src/traits.rs +++ b/crates/ra_hir/src/traits.rs @@ -9,13 +9,13 @@ use crate::{ db::{AstDatabase, DefDatabase}, ids::LocationCtx, name::AsName, - Const, Function, HasSource, Module, Name, Trait, TypeAlias, + AssocItem, Const, Function, HasSource, Module, Name, Trait, TypeAlias, }; #[derive(Debug, Clone, PartialEq, Eq)] pub struct TraitData { name: Option, - items: Vec, + items: Vec, auto: bool, } @@ -48,7 +48,7 @@ impl TraitData { &self.name } - pub(crate) fn items(&self) -> &[TraitItem] { + pub(crate) fn items(&self) -> &[AssocItem] { &self.items } @@ -57,22 +57,9 @@ impl TraitData { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum TraitItem { - Function(Function), - Const(Const), - TypeAlias(TypeAlias), - // Existential -} -// FIXME: not every function, ... is actually a trait item. maybe we should make -// sure that you can only turn actual trait items into TraitItems. This would -// require not implementing From, and instead having some checked way of -// casting them. -impl_froms!(TraitItem: Function, Const, TypeAlias); - #[derive(Debug, Clone, PartialEq, Eq)] pub struct TraitItemsIndex { - traits_by_def: FxHashMap, + traits_by_def: FxHashMap, } impl TraitItemsIndex { @@ -88,7 +75,7 @@ impl TraitItemsIndex { index } - pub(crate) fn get_parent_trait(&self, item: TraitItem) -> Option { + pub(crate) fn get_parent_trait(&self, item: AssocItem) -> Option { self.traits_by_def.get(&item).cloned() } } diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index 181be0fcc31..70da7f3113a 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -576,34 +576,32 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { // Find impl // FIXME: consider trait candidates - let def = ty.clone().iterate_impl_items(self.db, krate, |item| match item { - crate::ImplItem::Method(func) => { + let item = ty.clone().iterate_impl_items(self.db, krate, |item| match item { + AssocItem::Function(func) => { if segment.name == func.name(self.db) { - Some(ValueNs::Function(func)) + Some(AssocItem::Function(func)) } else { None } } - crate::ImplItem::Const(konst) => { + AssocItem::Const(konst) => { if konst.name(self.db).map_or(false, |n| n == segment.name) { - Some(ValueNs::Const(konst)) + Some(AssocItem::Const(konst)) } else { None } } - crate::ImplItem::TypeAlias(_) => None, + AssocItem::TypeAlias(_) => None, })?; + let def = match item { + AssocItem::Function(f) => ValueNs::Function(f), + AssocItem::Const(c) => ValueNs::Const(c), + AssocItem::TypeAlias(_) => unreachable!(), + }; let substs = self.find_self_types(&def, ty); - self.write_assoc_resolution( - id, - match def { - ValueNs::Function(f) => AssocItem::Function(f), - ValueNs::Const(c) => AssocItem::Const(c), - _ => unreachable!(), - }, - ); + self.write_assoc_resolution(id, item); Some((def, substs)) } diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index be63806d433..8b46b11a9c4 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -11,13 +11,12 @@ use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitR use crate::{ db::HirDatabase, generics::HasGenericParams, - impl_block::{ImplBlock, ImplId, ImplItem}, + impl_block::{ImplBlock, ImplId}, nameres::CrateModuleId, resolve::Resolver, - traits::TraitItem, ty::primitive::{FloatBitness, UncertainFloatTy, UncertainIntTy}, ty::{Ty, TypeCtor}, - Crate, Function, Module, Name, Trait, + AssocItem, Crate, Function, Module, Name, Trait, }; /// This is used as a key for indexing impls. @@ -232,7 +231,7 @@ fn iterate_trait_method_candidates( // iteration let mut known_implemented = inherently_implemented; for item in data.items() { - if let TraitItem::Function(m) = *item { + if let AssocItem::Function(m) = *item { let data = m.data(db); if name.map_or(true, |name| data.name() == name) && data.has_self_param() { if !known_implemented { @@ -264,7 +263,7 @@ fn iterate_inherent_methods( for impl_block in impls.lookup_impl_blocks(&ty.value) { for item in impl_block.items(db) { - if let ImplItem::Method(f) = item { + if let AssocItem::Function(f) = item { let data = f.data(db); if name.map_or(true, |name| data.name() == name) && data.has_self_param() { if let Some(result) = callback(&ty.value, f) { @@ -304,7 +303,7 @@ impl Ty { self, db: &impl HirDatabase, krate: Crate, - mut callback: impl FnMut(ImplItem) -> Option, + mut callback: impl FnMut(AssocItem) -> Option, ) -> Option { for krate in def_crates(db, krate, &self)? { let impls = db.impls_in_crate(krate); diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs index c748e9d84a1..693d9b28fd6 100644 --- a/crates/ra_hir/src/ty/traits/chalk.rs +++ b/crates/ra_hir/src/ty/traits/chalk.rs @@ -21,7 +21,7 @@ use crate::{ ApplicationTy, CallableDef, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk, }, - Crate, HasGenericParams, ImplBlock, ImplItem, Trait, TypeAlias, + AssocItem, Crate, HasGenericParams, ImplBlock, Trait, TypeAlias, }; /// This represents a trait whose name we could not resolve. @@ -496,7 +496,7 @@ pub(crate) fn trait_datum_query( .items(db) .into_iter() .filter_map(|trait_item| match trait_item { - crate::traits::TraitItem::TypeAlias(type_alias) => Some(type_alias), + crate::AssocItem::TypeAlias(type_alias) => Some(type_alias), _ => None, }) .map(|type_alias| type_alias.to_chalk(db)) @@ -616,7 +616,7 @@ pub(crate) fn impl_datum_query( .items(db) .into_iter() .filter_map(|item| match item { - ImplItem::TypeAlias(t) => Some(t), + AssocItem::TypeAlias(t) => Some(t), _ => None, }) .filter_map(|t| { diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs index e1c8d6ab0ec..e9fec54d868 100644 --- a/crates/ra_ide_api/src/completion/complete_path.rs +++ b/crates/ra_ide_api/src/completion/complete_path.rs @@ -52,14 +52,14 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) { if let Some(krate) = krate { ty.iterate_impl_items(ctx.db, krate, |item| { match item { - hir::ImplItem::Method(func) => { + hir::AssocItem::Function(func) => { let data = func.data(ctx.db); if !data.has_self_param() { acc.add_function(ctx, func); } } - hir::ImplItem::Const(ct) => acc.add_const(ctx, ct), - hir::ImplItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty), + hir::AssocItem::Const(ct) => acc.add_const(ctx, ct), + hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty), } None::<()> });