From 78111620a33c57b58b07ebf044a7d53dc56176ef Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Thu, 26 Dec 2019 16:22:15 +0100 Subject: Remove visibility query, instead add struct field visibility to data Methods should be handled the same, and for items the visibility will be in the def map. --- crates/ra_hir_def/src/adt.rs | 44 ++++++++++++++++----------- crates/ra_hir_def/src/db.rs | 6 +--- crates/ra_hir_def/src/lib.rs | 23 -------------- crates/ra_hir_def/src/visibility.rs | 60 ++++--------------------------------- 4 files changed, 33 insertions(+), 100 deletions(-) (limited to 'crates/ra_hir_def/src') diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs index d9ea693e3..aac5f3e15 100644 --- a/crates/ra_hir_def/src/adt.rs +++ b/crates/ra_hir_def/src/adt.rs @@ -9,11 +9,12 @@ use hir_expand::{ }; use ra_arena::{map::ArenaMap, Arena}; use ra_prof::profile; -use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; +use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner}; use crate::{ - db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef, EnumId, - LocalEnumVariantId, LocalStructFieldId, Lookup, StructId, UnionId, VariantId, + db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef, + visibility::RawVisibility, EnumId, LocalEnumVariantId, LocalStructFieldId, Lookup, StructId, + UnionId, VariantId, }; /// Note that we use `StructData` for unions as well! @@ -47,13 +48,14 @@ pub enum VariantData { pub struct StructFieldData { pub name: Name, pub type_ref: TypeRef, + pub visibility: RawVisibility, } impl StructData { pub(crate) fn struct_data_query(db: &impl DefDatabase, id: StructId) -> Arc { let src = id.lookup(db).source(db); let name = src.value.name().map_or_else(Name::missing, |n| n.as_name()); - let variant_data = VariantData::new(src.value.kind()); + let variant_data = VariantData::new(db, src.map(|s| s.kind())); let variant_data = Arc::new(variant_data); Arc::new(StructData { name, variant_data }) } @@ -61,10 +63,12 @@ impl StructData { let src = id.lookup(db).source(db); let name = src.value.name().map_or_else(Name::missing, |n| n.as_name()); let variant_data = VariantData::new( - src.value - .record_field_def_list() - .map(ast::StructKind::Record) - .unwrap_or(ast::StructKind::Unit), + db, + src.map(|s| { + s.record_field_def_list() + .map(ast::StructKind::Record) + .unwrap_or(ast::StructKind::Unit) + }), ); let variant_data = Arc::new(variant_data); Arc::new(StructData { name, variant_data }) @@ -77,7 +81,7 @@ impl EnumData { let src = e.lookup(db).source(db); let name = src.value.name().map_or_else(Name::missing, |n| n.as_name()); let mut trace = Trace::new_for_arena(); - lower_enum(&mut trace, &src.value); + lower_enum(db, &mut trace, &src); Arc::new(EnumData { name, variants: trace.into_arena() }) } @@ -93,30 +97,31 @@ impl HasChildSource for EnumId { fn child_source(&self, db: &impl DefDatabase) -> InFile> { let src = self.lookup(db).source(db); let mut trace = Trace::new_for_map(); - lower_enum(&mut trace, &src.value); + lower_enum(db, &mut trace, &src); src.with_value(trace.into_map()) } } fn lower_enum( + db: &impl DefDatabase, trace: &mut Trace, - ast: &ast::EnumDef, + ast: &InFile, ) { - for var in ast.variant_list().into_iter().flat_map(|it| it.variants()) { + for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) { trace.alloc( || var.clone(), || EnumVariantData { name: var.name().map_or_else(Name::missing, |it| it.as_name()), - variant_data: Arc::new(VariantData::new(var.kind())), + variant_data: Arc::new(VariantData::new(db, ast.with_value(var.kind()))), }, ); } } impl VariantData { - fn new(flavor: ast::StructKind) -> Self { + fn new(db: &impl DefDatabase, flavor: InFile) -> Self { let mut trace = Trace::new_for_arena(); - match lower_struct(&mut trace, &flavor) { + match lower_struct(db, &mut trace, &flavor) { StructKind::Tuple => VariantData::Tuple(trace.into_arena()), StructKind::Record => VariantData::Record(trace.into_arena()), StructKind::Unit => VariantData::Unit, @@ -163,7 +168,7 @@ impl HasChildSource for VariantId { }), }; let mut trace = Trace::new_for_map(); - lower_struct(&mut trace, &src.value); + lower_struct(db, &mut trace, &src); src.with_value(trace.into_map()) } } @@ -175,14 +180,15 @@ enum StructKind { } fn lower_struct( + db: &impl DefDatabase, trace: &mut Trace< LocalStructFieldId, StructFieldData, Either, >, - ast: &ast::StructKind, + ast: &InFile, ) -> StructKind { - match ast { + match &ast.value { ast::StructKind::Tuple(fl) => { for (i, fd) in fl.fields().enumerate() { trace.alloc( @@ -190,6 +196,7 @@ fn lower_struct( || StructFieldData { name: Name::new_tuple_field(i), type_ref: TypeRef::from_ast_opt(fd.type_ref()), + visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())), }, ); } @@ -202,6 +209,7 @@ fn lower_struct( || StructFieldData { name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing), type_ref: TypeRef::from_ast_opt(fd.ascribed_type()), + visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())), }, ); } diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs index 6bc0a8486..c55fd4111 100644 --- a/crates/ra_hir_def/src/db.rs +++ b/crates/ra_hir_def/src/db.rs @@ -14,10 +14,9 @@ use crate::{ generics::GenericParams, lang_item::{LangItemTarget, LangItems}, nameres::{raw::RawItems, CrateDefMap}, - visibility::RawVisibility, AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId, - TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VisibilityDefId, + TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, }; #[salsa::query_group(InternDatabaseStorage)] @@ -91,9 +90,6 @@ pub trait DefDatabase: InternDatabase + AstDatabase { #[salsa::invoke(Attrs::attrs_query)] fn attrs(&self, def: AttrDefId) -> Attrs; - #[salsa::invoke(RawVisibility::visibility_query)] - fn visibility(&self, def: VisibilityDefId) -> RawVisibility; - #[salsa::invoke(LangItems::module_lang_items_query)] fn module_lang_items(&self, module: ModuleId) -> Option>; diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 72a59d867..61f044ecf 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -325,29 +325,6 @@ impl_froms!( ImplId ); -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] -pub enum VisibilityDefId { - ModuleId(ModuleId), - StructFieldId(StructFieldId), - AdtId(AdtId), - FunctionId(FunctionId), - StaticId(StaticId), - ConstId(ConstId), - TraitId(TraitId), - TypeAliasId(TypeAliasId), -} - -impl_froms!( - VisibilityDefId: ModuleId, - StructFieldId, - AdtId(StructId, EnumId, UnionId), - StaticId, - ConstId, - FunctionId, - TraitId, - TypeAliasId -); - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum VariantId { EnumVariantId(EnumVariantId), diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs index e4c25ab7d..dccf2776e 100644 --- a/crates/ra_hir_def/src/visibility.rs +++ b/crates/ra_hir_def/src/visibility.rs @@ -2,16 +2,13 @@ use std::sync::Arc; -use either::Either; - use hir_expand::{hygiene::Hygiene, InFile}; -use ra_syntax::ast::{self, VisibilityOwner}; +use ra_syntax::ast; use crate::{ db::DefDatabase, path::{ModPath, PathKind}, - src::{HasChildSource, HasSource}, - AdtId, Lookup, ModuleId, VisibilityDefId, + ModuleId, }; /// Visibility of an item, not yet resolved. @@ -28,51 +25,15 @@ pub enum RawVisibility { } impl RawVisibility { - pub(crate) fn visibility_query(db: &impl DefDatabase, def: VisibilityDefId) -> RawVisibility { - match def { - VisibilityDefId::ModuleId(module) => { - let def_map = db.crate_def_map(module.krate); - let src = match def_map[module.local_id].declaration_source(db) { - Some(it) => it, - None => return RawVisibility::private(), - }; - RawVisibility::from_ast(db, src.map(|it| it.visibility())) - } - VisibilityDefId::StructFieldId(it) => { - let src = it.parent.child_source(db); - let is_enum = match it.parent { - crate::VariantId::EnumVariantId(_) => true, - _ => false, - }; - let vis_node = src.map(|m| match &m[it.local_id] { - Either::Left(tuple) => tuple.visibility(), - Either::Right(record) => record.visibility(), - }); - if vis_node.value.is_none() && is_enum { - RawVisibility::Public - } else { - RawVisibility::from_ast(db, vis_node) - } - } - VisibilityDefId::AdtId(it) => match it { - AdtId::StructId(it) => visibility_from_loc(it.lookup(db), db), - AdtId::EnumId(it) => visibility_from_loc(it.lookup(db), db), - AdtId::UnionId(it) => visibility_from_loc(it.lookup(db), db), - }, - VisibilityDefId::TraitId(it) => visibility_from_loc(it.lookup(db), db), - VisibilityDefId::ConstId(it) => visibility_from_loc(it.lookup(db), db), - VisibilityDefId::StaticId(it) => visibility_from_loc(it.lookup(db), db), - VisibilityDefId::FunctionId(it) => visibility_from_loc(it.lookup(db), db), - VisibilityDefId::TypeAliasId(it) => visibility_from_loc(it.lookup(db), db), - } - } - fn private() -> RawVisibility { let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() }; RawVisibility::Module(Arc::new(path)) } - fn from_ast(db: &impl DefDatabase, node: InFile>) -> RawVisibility { + pub(crate) fn from_ast( + db: &impl DefDatabase, + node: InFile>, + ) -> RawVisibility { Self::from_ast_with_hygiene(node.value, &Hygiene::new(db, node.file_id)) } @@ -155,12 +116,3 @@ impl Visibility { ancestors.any(|m| m == to_module.local_id) } } - -fn visibility_from_loc(node: T, db: &impl DefDatabase) -> RawVisibility -where - T: HasSource, - T::Value: ast::VisibilityOwner, -{ - let src = node.source(db); - RawVisibility::from_ast(db, src.map(|n| n.visibility())) -} -- cgit v1.2.3