From 78f3b0627cf4a5d34aaf63c7b5a2e1b744a11b14 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 22 Nov 2019 17:10:51 +0300 Subject: Move FunctionData to hir_def --- crates/ra_hir_def/src/db.rs | 7 ++++- crates/ra_hir_def/src/function.rs | 61 +++++++++++++++++++++++++++++++++++++++ crates/ra_hir_def/src/lib.rs | 1 + 3 files changed, 68 insertions(+), 1 deletion(-) create mode 100644 crates/ra_hir_def/src/function.rs (limited to 'crates/ra_hir_def') diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs index 5bbdaa4b2..02e649cc7 100644 --- a/crates/ra_hir_def/src/db.rs +++ b/crates/ra_hir_def/src/db.rs @@ -8,6 +8,7 @@ use ra_syntax::ast; use crate::{ adt::{EnumData, StructData}, body::{scope::ExprScopes, Body, BodySourceMap}, + function::FunctionData, generics::GenericParams, impls::ImplData, nameres::{ @@ -16,7 +17,8 @@ use crate::{ }, traits::TraitData, type_alias::TypeAliasData, - DefWithBodyId, EnumId, GenericDefId, ImplId, ItemLoc, StructOrUnionId, TraitId, TypeAliasId, + DefWithBodyId, EnumId, FunctionId, GenericDefId, ImplId, ItemLoc, StructOrUnionId, TraitId, + TypeAliasId, }; #[salsa::query_group(InternDatabaseStorage)] @@ -68,6 +70,9 @@ pub trait DefDatabase2: InternDatabase + AstDatabase { #[salsa::invoke(TypeAliasData::type_alias_data_query)] fn type_alias_data(&self, e: TypeAliasId) -> Arc; + #[salsa::invoke(FunctionData::fn_data_query)] + fn function_data(&self, func: FunctionId) -> Arc; + #[salsa::invoke(Body::body_with_source_map_query)] fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc, Arc); diff --git a/crates/ra_hir_def/src/function.rs b/crates/ra_hir_def/src/function.rs new file mode 100644 index 000000000..33265275e --- /dev/null +++ b/crates/ra_hir_def/src/function.rs @@ -0,0 +1,61 @@ +use std::sync::Arc; + +use hir_expand::name::{self, AsName, Name}; +use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; + +use crate::{ + db::DefDatabase2, + type_ref::{Mutability, TypeRef}, + FunctionId, HasSource, Lookup, +}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FunctionData { + pub name: Name, + pub params: Vec, + pub ret_type: TypeRef, + /// True if the first param is `self`. This is relevant to decide whether this + /// can be called as a method. + pub has_self_param: bool, +} + +impl FunctionData { + pub(crate) fn fn_data_query(db: &impl DefDatabase2, func: FunctionId) -> Arc { + let src = func.lookup(db).source(db); + let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing); + let mut params = Vec::new(); + let mut has_self_param = false; + if let Some(param_list) = src.value.param_list() { + if let Some(self_param) = param_list.self_param() { + let self_type = if let Some(type_ref) = self_param.ascribed_type() { + TypeRef::from_ast(type_ref) + } else { + let self_type = TypeRef::Path(name::SELF_TYPE.into()); + match self_param.kind() { + ast::SelfParamKind::Owned => self_type, + ast::SelfParamKind::Ref => { + TypeRef::Reference(Box::new(self_type), Mutability::Shared) + } + ast::SelfParamKind::MutRef => { + TypeRef::Reference(Box::new(self_type), Mutability::Mut) + } + } + }; + params.push(self_type); + has_self_param = true; + } + for param in param_list.params() { + let type_ref = TypeRef::from_ast_opt(param.ascribed_type()); + params.push(type_ref); + } + } + let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) { + TypeRef::from_ast(type_ref) + } else { + TypeRef::unit() + }; + + let sig = FunctionData { name, params, ret_type, has_self_param }; + Arc::new(sig) + } +} diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 268144462..14ccad043 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -21,6 +21,7 @@ pub mod generics; pub mod traits; pub mod resolver; pub mod type_alias; +pub mod function; #[cfg(test)] mod test_db; -- cgit v1.2.3 From b315f05cf160a11b9012fcde2a9aefc240e39135 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 22 Nov 2019 17:32:10 +0300 Subject: Move data to a single file --- crates/ra_hir_def/src/data.rs | 206 ++++++++++++++++++++++++++++++++++++ crates/ra_hir_def/src/db.rs | 5 +- crates/ra_hir_def/src/function.rs | 61 ----------- crates/ra_hir_def/src/impls.rs | 86 --------------- crates/ra_hir_def/src/lib.rs | 5 +- crates/ra_hir_def/src/traits.rs | 66 ------------ crates/ra_hir_def/src/type_alias.rs | 27 ----- 7 files changed, 208 insertions(+), 248 deletions(-) create mode 100644 crates/ra_hir_def/src/data.rs delete mode 100644 crates/ra_hir_def/src/function.rs delete mode 100644 crates/ra_hir_def/src/impls.rs delete mode 100644 crates/ra_hir_def/src/traits.rs delete mode 100644 crates/ra_hir_def/src/type_alias.rs (limited to 'crates/ra_hir_def') diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs new file mode 100644 index 000000000..b73e0d0a7 --- /dev/null +++ b/crates/ra_hir_def/src/data.rs @@ -0,0 +1,206 @@ +use std::sync::Arc; + +use hir_expand::{ + name::{self, AsName, Name}, + AstId, +}; +use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; + +use crate::{ + db::DefDatabase2, + type_ref::{Mutability, TypeRef}, + AssocItemId, AstItemDef, ConstLoc, ContainerId, FunctionId, FunctionLoc, HasSource, ImplId, + Intern, Lookup, TraitId, TypeAliasId, TypeAliasLoc, +}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FunctionData { + pub name: Name, + pub params: Vec, + pub ret_type: TypeRef, + /// True if the first param is `self`. This is relevant to decide whether this + /// can be called as a method. + pub has_self_param: bool, +} + +impl FunctionData { + pub(crate) fn fn_data_query(db: &impl DefDatabase2, func: FunctionId) -> Arc { + let src = func.lookup(db).source(db); + let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing); + let mut params = Vec::new(); + let mut has_self_param = false; + if let Some(param_list) = src.value.param_list() { + if let Some(self_param) = param_list.self_param() { + let self_type = if let Some(type_ref) = self_param.ascribed_type() { + TypeRef::from_ast(type_ref) + } else { + let self_type = TypeRef::Path(name::SELF_TYPE.into()); + match self_param.kind() { + ast::SelfParamKind::Owned => self_type, + ast::SelfParamKind::Ref => { + TypeRef::Reference(Box::new(self_type), Mutability::Shared) + } + ast::SelfParamKind::MutRef => { + TypeRef::Reference(Box::new(self_type), Mutability::Mut) + } + } + }; + params.push(self_type); + has_self_param = true; + } + for param in param_list.params() { + let type_ref = TypeRef::from_ast_opt(param.ascribed_type()); + params.push(type_ref); + } + } + let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) { + TypeRef::from_ast(type_ref) + } else { + TypeRef::unit() + }; + + let sig = FunctionData { name, params, ret_type, has_self_param }; + Arc::new(sig) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TypeAliasData { + pub name: Name, + pub type_ref: Option, +} + +impl TypeAliasData { + pub(crate) fn type_alias_data_query( + db: &impl DefDatabase2, + typ: TypeAliasId, + ) -> Arc { + let node = typ.lookup(db).source(db).value; + let name = node.name().map_or_else(Name::missing, |n| n.as_name()); + let type_ref = node.type_ref().map(TypeRef::from_ast); + Arc::new(TypeAliasData { name, type_ref }) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TraitData { + pub name: Option, + pub items: Vec, + pub auto: bool, +} + +impl TraitData { + pub(crate) fn trait_data_query(db: &impl DefDatabase2, tr: TraitId) -> Arc { + let src = tr.source(db); + let name = src.value.name().map(|n| n.as_name()); + let auto = src.value.is_auto(); + let ast_id_map = db.ast_id_map(src.file_id); + let items = if let Some(item_list) = src.value.item_list() { + item_list + .impl_items() + .map(|item_node| match item_node { + ast::ImplItem::FnDef(it) => FunctionLoc { + container: ContainerId::TraitId(tr), + ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)), + } + .intern(db) + .into(), + ast::ImplItem::ConstDef(it) => ConstLoc { + container: ContainerId::TraitId(tr), + ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)), + } + .intern(db) + .into(), + ast::ImplItem::TypeAliasDef(it) => TypeAliasLoc { + container: ContainerId::TraitId(tr), + ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)), + } + .intern(db) + .into(), + }) + .collect() + } else { + Vec::new() + }; + Arc::new(TraitData { name, items, auto }) + } + + pub fn associated_types(&self) -> impl Iterator + '_ { + self.items.iter().filter_map(|item| match item { + AssocItemId::TypeAliasId(t) => Some(*t), + _ => None, + }) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ImplData { + target_trait: Option, + target_type: TypeRef, + items: Vec, + negative: bool, +} + +impl ImplData { + pub(crate) fn impl_data_query(db: &impl DefDatabase2, id: ImplId) -> Arc { + let src = id.source(db); + let items = db.ast_id_map(src.file_id); + + let target_trait = src.value.target_trait().map(TypeRef::from_ast); + let target_type = TypeRef::from_ast_opt(src.value.target_type()); + let negative = src.value.is_negative(); + + let items = if let Some(item_list) = src.value.item_list() { + item_list + .impl_items() + .map(|item_node| match item_node { + ast::ImplItem::FnDef(it) => { + let def = FunctionLoc { + container: ContainerId::ImplId(id), + ast_id: AstId::new(src.file_id, items.ast_id(&it)), + } + .intern(db); + def.into() + } + ast::ImplItem::ConstDef(it) => { + let def = ConstLoc { + container: ContainerId::ImplId(id), + ast_id: AstId::new(src.file_id, items.ast_id(&it)), + } + .intern(db); + def.into() + } + ast::ImplItem::TypeAliasDef(it) => { + let def = TypeAliasLoc { + container: ContainerId::ImplId(id), + ast_id: AstId::new(src.file_id, items.ast_id(&it)), + } + .intern(db); + def.into() + } + }) + .collect() + } else { + Vec::new() + }; + + let res = ImplData { target_trait, target_type, items, negative }; + Arc::new(res) + } + + pub fn target_trait(&self) -> Option<&TypeRef> { + self.target_trait.as_ref() + } + + pub fn target_type(&self) -> &TypeRef { + &self.target_type + } + + pub fn items(&self) -> &[AssocItemId] { + &self.items + } + + pub fn is_negative(&self) -> bool { + self.negative + } +} diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs index 02e649cc7..8c1784ec9 100644 --- a/crates/ra_hir_def/src/db.rs +++ b/crates/ra_hir_def/src/db.rs @@ -8,15 +8,12 @@ use ra_syntax::ast; use crate::{ adt::{EnumData, StructData}, body::{scope::ExprScopes, Body, BodySourceMap}, - function::FunctionData, + data::{FunctionData, ImplData, TraitData, TypeAliasData}, generics::GenericParams, - impls::ImplData, nameres::{ raw::{ImportSourceMap, RawItems}, CrateDefMap, }, - traits::TraitData, - type_alias::TypeAliasData, DefWithBodyId, EnumId, FunctionId, GenericDefId, ImplId, ItemLoc, StructOrUnionId, TraitId, TypeAliasId, }; diff --git a/crates/ra_hir_def/src/function.rs b/crates/ra_hir_def/src/function.rs deleted file mode 100644 index 33265275e..000000000 --- a/crates/ra_hir_def/src/function.rs +++ /dev/null @@ -1,61 +0,0 @@ -use std::sync::Arc; - -use hir_expand::name::{self, AsName, Name}; -use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; - -use crate::{ - db::DefDatabase2, - type_ref::{Mutability, TypeRef}, - FunctionId, HasSource, Lookup, -}; - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct FunctionData { - pub name: Name, - pub params: Vec, - pub ret_type: TypeRef, - /// True if the first param is `self`. This is relevant to decide whether this - /// can be called as a method. - pub has_self_param: bool, -} - -impl FunctionData { - pub(crate) fn fn_data_query(db: &impl DefDatabase2, func: FunctionId) -> Arc { - let src = func.lookup(db).source(db); - let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing); - let mut params = Vec::new(); - let mut has_self_param = false; - if let Some(param_list) = src.value.param_list() { - if let Some(self_param) = param_list.self_param() { - let self_type = if let Some(type_ref) = self_param.ascribed_type() { - TypeRef::from_ast(type_ref) - } else { - let self_type = TypeRef::Path(name::SELF_TYPE.into()); - match self_param.kind() { - ast::SelfParamKind::Owned => self_type, - ast::SelfParamKind::Ref => { - TypeRef::Reference(Box::new(self_type), Mutability::Shared) - } - ast::SelfParamKind::MutRef => { - TypeRef::Reference(Box::new(self_type), Mutability::Mut) - } - } - }; - params.push(self_type); - has_self_param = true; - } - for param in param_list.params() { - let type_ref = TypeRef::from_ast_opt(param.ascribed_type()); - params.push(type_ref); - } - } - let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) { - TypeRef::from_ast(type_ref) - } else { - TypeRef::unit() - }; - - let sig = FunctionData { name, params, ret_type, has_self_param }; - Arc::new(sig) - } -} diff --git a/crates/ra_hir_def/src/impls.rs b/crates/ra_hir_def/src/impls.rs deleted file mode 100644 index 750a869f2..000000000 --- a/crates/ra_hir_def/src/impls.rs +++ /dev/null @@ -1,86 +0,0 @@ -//! Defines hir-level representation of impls. -//! -//! The handling is similar, but is not quite the same as for other items, -//! because `impl`s don't have names. - -use std::sync::Arc; - -use hir_expand::AstId; -use ra_syntax::ast; - -use crate::{ - db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstLoc, ContainerId, - FunctionLoc, ImplId, Intern, TypeAliasLoc, -}; - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct ImplData { - target_trait: Option, - target_type: TypeRef, - items: Vec, - negative: bool, -} - -impl ImplData { - pub(crate) fn impl_data_query(db: &impl DefDatabase2, id: ImplId) -> Arc { - let src = id.source(db); - let items = db.ast_id_map(src.file_id); - - let target_trait = src.value.target_trait().map(TypeRef::from_ast); - let target_type = TypeRef::from_ast_opt(src.value.target_type()); - let negative = src.value.is_negative(); - - let items = if let Some(item_list) = src.value.item_list() { - item_list - .impl_items() - .map(|item_node| match item_node { - ast::ImplItem::FnDef(it) => { - let def = FunctionLoc { - container: ContainerId::ImplId(id), - ast_id: AstId::new(src.file_id, items.ast_id(&it)), - } - .intern(db); - def.into() - } - ast::ImplItem::ConstDef(it) => { - let def = ConstLoc { - container: ContainerId::ImplId(id), - ast_id: AstId::new(src.file_id, items.ast_id(&it)), - } - .intern(db); - def.into() - } - ast::ImplItem::TypeAliasDef(it) => { - let def = TypeAliasLoc { - container: ContainerId::ImplId(id), - ast_id: AstId::new(src.file_id, items.ast_id(&it)), - } - .intern(db); - def.into() - } - }) - .collect() - } else { - Vec::new() - }; - - let res = ImplData { target_trait, target_type, items, negative }; - Arc::new(res) - } - - pub fn target_trait(&self) -> Option<&TypeRef> { - self.target_trait.as_ref() - } - - pub fn target_type(&self) -> &TypeRef { - &self.target_type - } - - pub fn items(&self) -> &[AssocItemId] { - &self.items - } - - pub fn is_negative(&self) -> bool { - self.negative - } -} diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 14ccad043..3a0420da0 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -13,15 +13,12 @@ pub mod path; pub mod type_ref; pub mod builtin_type; pub mod adt; -pub mod impls; pub mod diagnostics; pub mod expr; pub mod body; pub mod generics; -pub mod traits; pub mod resolver; -pub mod type_alias; -pub mod function; +pub mod data; #[cfg(test)] mod test_db; diff --git a/crates/ra_hir_def/src/traits.rs b/crates/ra_hir_def/src/traits.rs deleted file mode 100644 index 6c2d5b2a9..000000000 --- a/crates/ra_hir_def/src/traits.rs +++ /dev/null @@ -1,66 +0,0 @@ -//! HIR for trait definitions. - -use std::sync::Arc; - -use hir_expand::{ - name::{AsName, Name}, - AstId, -}; - -use ra_syntax::ast::{self, NameOwner}; - -use crate::{ - db::DefDatabase2, AssocItemId, AstItemDef, ConstLoc, ContainerId, FunctionLoc, Intern, TraitId, - TypeAliasId, TypeAliasLoc, -}; - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct TraitData { - pub name: Option, - pub items: Vec, - pub auto: bool, -} - -impl TraitData { - pub(crate) fn trait_data_query(db: &impl DefDatabase2, tr: TraitId) -> Arc { - let src = tr.source(db); - let name = src.value.name().map(|n| n.as_name()); - let auto = src.value.is_auto(); - let ast_id_map = db.ast_id_map(src.file_id); - let items = if let Some(item_list) = src.value.item_list() { - item_list - .impl_items() - .map(|item_node| match item_node { - ast::ImplItem::FnDef(it) => FunctionLoc { - container: ContainerId::TraitId(tr), - ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)), - } - .intern(db) - .into(), - ast::ImplItem::ConstDef(it) => ConstLoc { - container: ContainerId::TraitId(tr), - ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)), - } - .intern(db) - .into(), - ast::ImplItem::TypeAliasDef(it) => TypeAliasLoc { - container: ContainerId::TraitId(tr), - ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)), - } - .intern(db) - .into(), - }) - .collect() - } else { - Vec::new() - }; - Arc::new(TraitData { name, items, auto }) - } - - pub fn associated_types(&self) -> impl Iterator + '_ { - self.items.iter().filter_map(|item| match item { - AssocItemId::TypeAliasId(t) => Some(*t), - _ => None, - }) - } -} diff --git a/crates/ra_hir_def/src/type_alias.rs b/crates/ra_hir_def/src/type_alias.rs deleted file mode 100644 index c0b49aa7c..000000000 --- a/crates/ra_hir_def/src/type_alias.rs +++ /dev/null @@ -1,27 +0,0 @@ -//! HIR for type aliases (i.e. the `type` keyword). - -use std::sync::Arc; - -use hir_expand::name::{AsName, Name}; - -use ra_syntax::ast::NameOwner; - -use crate::{db::DefDatabase2, type_ref::TypeRef, HasSource, Lookup, TypeAliasId}; - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct TypeAliasData { - pub name: Name, - pub type_ref: Option, -} - -impl TypeAliasData { - pub(crate) fn type_alias_data_query( - db: &impl DefDatabase2, - typ: TypeAliasId, - ) -> Arc { - let node = typ.lookup(db).source(db).value; - let name = node.name().map_or_else(Name::missing, |n| n.as_name()); - let type_ref = node.type_ref().map(TypeRef::from_ast); - Arc::new(TypeAliasData { name, type_ref }) - } -} -- cgit v1.2.3 From 64df759418a83fd05fab850b8351fcddbdd3ef63 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 22 Nov 2019 17:33:53 +0300 Subject: Make ImplData's fields public --- crates/ra_hir_def/src/data.rs | 30 ++++++++---------------------- 1 file changed, 8 insertions(+), 22 deletions(-) (limited to 'crates/ra_hir_def') diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs index b73e0d0a7..ba47629db 100644 --- a/crates/ra_hir_def/src/data.rs +++ b/crates/ra_hir_def/src/data.rs @@ -1,3 +1,5 @@ +//! Contains basic data about various HIR declarations. + use std::sync::Arc; use hir_expand::{ @@ -135,10 +137,10 @@ impl TraitData { #[derive(Debug, Clone, PartialEq, Eq)] pub struct ImplData { - target_trait: Option, - target_type: TypeRef, - items: Vec, - negative: bool, + pub target_trait: Option, + pub target_type: TypeRef, + pub items: Vec, + pub is_negative: bool, } impl ImplData { @@ -148,7 +150,7 @@ impl ImplData { let target_trait = src.value.target_trait().map(TypeRef::from_ast); let target_type = TypeRef::from_ast_opt(src.value.target_type()); - let negative = src.value.is_negative(); + let is_negative = src.value.is_negative(); let items = if let Some(item_list) = src.value.item_list() { item_list @@ -184,23 +186,7 @@ impl ImplData { Vec::new() }; - let res = ImplData { target_trait, target_type, items, negative }; + let res = ImplData { target_trait, target_type, items, is_negative }; Arc::new(res) } - - pub fn target_trait(&self) -> Option<&TypeRef> { - self.target_trait.as_ref() - } - - pub fn target_type(&self) -> &TypeRef { - &self.target_type - } - - pub fn items(&self) -> &[AssocItemId] { - &self.items - } - - pub fn is_negative(&self) -> bool { - self.negative - } } -- cgit v1.2.3