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/src/code_model.rs | 87 +++-------------------- crates/ra_hir/src/db.rs | 13 ++-- crates/ra_hir/src/lib.rs | 6 +- crates/ra_hir/src/ty/infer.rs | 13 ++-- crates/ra_hir/src/ty/lower.rs | 6 +- crates/ra_hir/src/ty/method_resolution.rs | 6 +- crates/ra_hir_def/src/db.rs | 7 +- crates/ra_hir_def/src/function.rs | 61 ++++++++++++++++ crates/ra_hir_def/src/lib.rs | 1 + crates/ra_ide_api/src/call_info.rs | 4 +- crates/ra_ide_api/src/change.rs | 2 +- crates/ra_ide_api/src/completion/complete_dot.rs | 3 +- crates/ra_ide_api/src/completion/complete_path.rs | 6 +- crates/ra_ide_api/src/completion/presentation.rs | 15 ++-- 14 files changed, 114 insertions(+), 116 deletions(-) create mode 100644 crates/ra_hir_def/src/function.rs (limited to 'crates') diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 72c9b466f..f426f8c9f 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -13,7 +13,7 @@ use hir_def::{ nameres::per_ns::PerNs, resolver::{HasResolver, TypeNs}, traits::TraitData, - type_ref::{Mutability, TypeRef}, + type_ref::TypeRef, ContainerId, CrateModuleId, HasModule, ImplId, LocalEnumVariantId, LocalStructFieldId, Lookup, ModuleId, UnionId, }; @@ -561,77 +561,6 @@ pub struct Function { pub(crate) id: FunctionId, } -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct FnData { - pub(crate) name: Name, - pub(crate) params: Vec, - pub(crate) ret_type: TypeRef, - /// True if the first param is `self`. This is relevant to decide whether this - /// can be called as a method. - pub(crate) has_self_param: bool, -} - -impl FnData { - pub(crate) fn fn_data_query( - db: &(impl DefDatabase + AstDatabase), - func: Function, - ) -> Arc { - let src = func.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 = FnData { name, params, ret_type, has_self_param }; - Arc::new(sig) - } - pub fn name(&self) -> &Name { - &self.name - } - - pub fn params(&self) -> &[TypeRef] { - &self.params - } - - pub fn ret_type(&self) -> &TypeRef { - &self.ret_type - } - - /// True if the first arg is `self`. This is relevant to decide whether this - /// can be called as a method. - pub fn has_self_param(&self) -> bool { - self.has_self_param - } -} - impl Function { pub fn module(self, db: &impl DefDatabase) -> Module { self.id.lookup(db).module(db).into() @@ -642,7 +571,15 @@ impl Function { } pub fn name(self, db: &impl HirDatabase) -> Name { - self.data(db).name.clone() + db.function_data(self.id).name.clone() + } + + pub fn has_self_param(self, db: &impl HirDatabase) -> bool { + db.function_data(self.id).has_self_param + } + + pub fn params(self, db: &impl HirDatabase) -> Vec { + db.function_data(self.id).params.clone() } pub(crate) fn body_source_map(self, db: &impl HirDatabase) -> Arc { @@ -657,10 +594,6 @@ impl Function { db.type_for_def(self.into(), Namespace::Values) } - pub fn data(self, db: &impl HirDatabase) -> Arc { - db.fn_data(self) - } - pub fn infer(self, db: &impl HirDatabase) -> Arc { db.infer(self.into()) } diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 1cfcb2fd2..8b9af0565 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -16,15 +16,15 @@ use crate::{ CallableDef, FnSig, GenericPredicate, InferenceResult, Namespace, Substs, Ty, TypableDef, TypeCtor, }, - Const, ConstData, Crate, DefWithBody, FnData, Function, GenericDef, ImplBlock, Module, Static, - StructField, Trait, + Const, ConstData, Crate, DefWithBody, GenericDef, ImplBlock, Module, Static, StructField, + Trait, }; pub use hir_def::db::{ BodyQuery, BodyWithSourceMapQuery, CrateDefMapQuery, DefDatabase2, DefDatabase2Storage, - EnumDataQuery, ExprScopesQuery, GenericParamsQuery, ImplDataQuery, InternDatabase, - InternDatabaseStorage, RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery, - TraitDataQuery, TypeAliasDataQuery, + EnumDataQuery, ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, + InternDatabase, InternDatabaseStorage, RawItemsQuery, RawItemsWithSourceMapQuery, + StructDataQuery, TraitDataQuery, TypeAliasDataQuery, }; pub use hir_expand::db::{ AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, @@ -35,9 +35,6 @@ pub use hir_expand::db::{ #[salsa::query_group(DefDatabaseStorage)] #[salsa::requires(AstDatabase)] pub trait DefDatabase: HirDebugDatabase + DefDatabase2 { - #[salsa::invoke(FnData::fn_data_query)] - fn fn_data(&self, func: Function) -> Arc; - #[salsa::invoke(ConstData::const_data_query)] fn const_data(&self, konst: Const) -> Arc; diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 8535629ca..d29cc9258 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -55,9 +55,9 @@ pub use crate::{ docs::{DocDef, Docs, Documentation}, src::{HasBodySource, HasSource}, Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum, - EnumVariant, FieldSource, FnData, Function, GenericDef, GenericParam, HasBody, ImplBlock, - Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef, Static, Struct, StructField, - Trait, TypeAlias, Union, VariantDef, + EnumVariant, FieldSource, Function, GenericDef, GenericParam, HasBody, ImplBlock, Local, + MacroDef, Module, ModuleDef, ModuleSource, ScopeDef, Static, Struct, StructField, Trait, + TypeAlias, Union, VariantDef, }, expr::ExprScopes, from_source::FromSource, diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index 69b13baef..41a51283d 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -22,6 +22,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue}; use rustc_hash::FxHashMap; use hir_def::{ + function::FunctionData, path::known, resolver::{HasResolver, Resolver, TypeNs}, type_ref::{Mutability, TypeRef}, @@ -43,8 +44,8 @@ use crate::{ db::HirDatabase, expr::{BindingAnnotation, Body, ExprId, PatId}, ty::infer::diagnostics::InferenceDiagnostic, - Adt, AssocItem, ConstData, DefWithBody, FloatTy, FnData, Function, HasBody, IntTy, Path, - StructField, Trait, VariantDef, + Adt, AssocItem, ConstData, DefWithBody, FloatTy, Function, HasBody, IntTy, Path, StructField, + Trait, VariantDef, }; macro_rules! ty_app { @@ -70,7 +71,7 @@ pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc ctx.collect_const(&c.data(db)), - DefWithBody::Function(ref f) => ctx.collect_fn(&f.data(db)), + DefWithBody::Function(ref f) => ctx.collect_fn(&db.function_data(f.id)), DefWithBody::Static(ref s) => ctx.collect_const(&s.data(db)), } @@ -562,14 +563,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { self.return_ty = self.make_ty(data.type_ref()); } - fn collect_fn(&mut self, data: &FnData) { + fn collect_fn(&mut self, data: &FunctionData) { let body = Arc::clone(&self.body); // avoid borrow checker problem - for (type_ref, pat) in data.params().iter().zip(body.params()) { + for (type_ref, pat) in data.params.iter().zip(body.params()) { let ty = self.make_ty(type_ref); self.infer_pat(*pat, &ty, BindingMode::default()); } - self.return_ty = self.make_ty(data.ret_type()); + self.return_ty = self.make_ty(&data.ret_type); } fn infer_body(&mut self) { diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index 75c552569..42daa9cb9 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs @@ -622,10 +622,10 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> } fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig { - let data = def.data(db); + let data = db.function_data(def.id); let resolver = def.id.resolver(db); - let params = data.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::>(); - let ret = Ty::from_hir(db, &resolver, data.ret_type()); + let params = data.params.iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::>(); + let ret = Ty::from_hir(db, &resolver, &data.ret_type); FnSig::from_params_and_return(params, ret) } diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index 64adb814d..f84aae26e 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -291,9 +291,9 @@ fn is_valid_candidate( ) -> bool { match item { AssocItem::Function(m) => { - let data = m.data(db); - name.map_or(true, |name| data.name() == name) - && (data.has_self_param() || mode == LookupMode::Path) + let data = db.function_data(m.id); + name.map_or(true, |name| data.name == *name) + && (data.has_self_param || mode == LookupMode::Path) } AssocItem::Const(c) => { name.map_or(true, |name| Some(name) == c.name(db).as_ref()) 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; diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs index 41ee81511..7c367230e 100644 --- a/crates/ra_ide_api/src/call_info.rs +++ b/crates/ra_ide_api/src/call_info.rs @@ -30,7 +30,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option { - (CallInfo::with_fn(db, it), it.data(db).has_self_param()) + (CallInfo::with_fn(db, it), it.has_self_param(db)) } hir::CallableDef::Struct(it) => (CallInfo::with_struct(db, it)?, false), hir::CallableDef::EnumVariant(it) => (CallInfo::with_enum_variant(db, it)?, false), @@ -38,7 +38,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option { let function = analyzer.resolve_method_call(&expr)?; - (CallInfo::with_fn(db, function), function.data(db).has_self_param()) + (CallInfo::with_fn(db, function), function.has_self_param(db)) } FnCallNode::MacroCallExpr(expr) => { let macro_def = analyzer.resolve_macro_call(db, &expr)?; diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs index 3c607d5b5..8a05b287f 100644 --- a/crates/ra_ide_api/src/change.rs +++ b/crates/ra_ide_api/src/change.rs @@ -313,7 +313,7 @@ impl RootDatabase { hir::db::RawItemsQuery hir::db::CrateDefMapQuery hir::db::GenericParamsQuery - hir::db::FnDataQuery + hir::db::FunctionDataQuery hir::db::TypeAliasDataQuery hir::db::ConstDataQuery hir::db::StaticDataQuery diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs index 4e2c497e1..5a3f9b5f6 100644 --- a/crates/ra_ide_api/src/completion/complete_dot.rs +++ b/crates/ra_ide_api/src/completion/complete_dot.rs @@ -59,8 +59,7 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) { let mut seen_methods = FxHashSet::default(); ctx.analyzer.iterate_method_candidates(ctx.db, receiver, None, |_ty, func| { - let data = func.data(ctx.db); - if data.has_self_param() && seen_methods.insert(data.name().clone()) { + if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) { acc.add_function(ctx, func); } None::<()> diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs index 5d974cf6d..802c7701a 100644 --- a/crates/ra_ide_api/src/completion/complete_path.rs +++ b/crates/ra_ide_api/src/completion/complete_path.rs @@ -53,8 +53,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) { ctx.analyzer.iterate_path_candidates(ctx.db, ty.clone(), None, |_ty, item| { match item { hir::AssocItem::Function(func) => { - let data = func.data(ctx.db); - if !data.has_self_param() { + if !func.has_self_param(ctx.db) { acc.add_function(ctx, func); } } @@ -80,8 +79,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) { for item in t.items(ctx.db) { match item { hir::AssocItem::Function(func) => { - let data = func.data(ctx.db); - if !data.has_self_param() { + if !func.has_self_param(ctx.db) { acc.add_function(ctx, func); } } diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs index bd464d193..50fdb0043 100644 --- a/crates/ra_ide_api/src/completion/presentation.rs +++ b/crates/ra_ide_api/src/completion/presentation.rs @@ -199,14 +199,17 @@ impl Completions { name: Option, func: hir::Function, ) { - let data = func.data(ctx.db); - let name = name.unwrap_or_else(|| data.name().to_string()); + let func_name = func.name(ctx.db); + let has_self_param = func.has_self_param(ctx.db); + let params = func.params(ctx.db); + + let name = name.unwrap_or_else(|| func_name.to_string()); let ast_node = func.source(ctx.db).value; let detail = function_label(&ast_node); let mut builder = CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone()) - .kind(if data.has_self_param() { + .kind(if has_self_param { CompletionItemKind::Method } else { CompletionItemKind::Function @@ -222,10 +225,10 @@ impl Completions { { tested_by!(inserts_parens_for_function_calls); let (snippet, label) = - if data.params().is_empty() || data.has_self_param() && data.params().len() == 1 { - (format!("{}()$0", data.name()), format!("{}()", name)) + if params.is_empty() || has_self_param && params.len() == 1 { + (format!("{}()$0", func_name), format!("{}()", name)) } else { - (format!("{}($0)", data.name()), format!("{}(…)", name)) + (format!("{}($0)", func_name), format!("{}(…)", name)) }; builder = builder.lookup_by(name).label(label).insert_snippet(snippet); } -- 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 --- crates/ra_ide_api/src/completion/presentation.rs | 11 +- 8 files changed, 213 insertions(+), 254 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') 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 }) - } -} diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs index 50fdb0043..896ad1517 100644 --- a/crates/ra_ide_api/src/completion/presentation.rs +++ b/crates/ra_ide_api/src/completion/presentation.rs @@ -224,12 +224,11 @@ impl Completions { && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis") { tested_by!(inserts_parens_for_function_calls); - let (snippet, label) = - if params.is_empty() || has_self_param && params.len() == 1 { - (format!("{}()$0", func_name), format!("{}()", name)) - } else { - (format!("{}($0)", func_name), format!("{}(…)", name)) - }; + let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 { + (format!("{}()$0", func_name), format!("{}()", name)) + } else { + (format!("{}($0)", func_name), format!("{}(…)", name)) + }; builder = builder.lookup_by(name).label(label).insert_snippet(snippet); } -- 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/src/code_model.rs | 2 +- crates/ra_hir/src/impl_block.rs | 8 ++++---- crates/ra_hir/src/ty/infer.rs | 2 +- crates/ra_hir_def/src/data.rs | 30 ++++++++---------------------- 4 files changed, 14 insertions(+), 28 deletions(-) (limited to 'crates') diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index f426f8c9f..3daf7488e 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -10,9 +10,9 @@ use hir_def::{ adt::VariantData, body::scope::ExprScopes, builtin_type::BuiltinType, + data::TraitData, nameres::per_ns::PerNs, resolver::{HasResolver, TypeNs}, - traits::TraitData, type_ref::TypeRef, ContainerId, CrateModuleId, HasModule, ImplId, LocalEnumVariantId, LocalStructFieldId, Lookup, ModuleId, UnionId, diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 774fa1d96..334eeebac 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -18,11 +18,11 @@ impl HasSource for ImplBlock { impl ImplBlock { pub fn target_trait(&self, db: &impl DefDatabase) -> Option { - db.impl_data(self.id).target_trait().cloned() + db.impl_data(self.id).target_trait.clone() } pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef { - db.impl_data(self.id).target_type().clone() + db.impl_data(self.id).target_type.clone() } pub fn target_ty(&self, db: &impl HirDatabase) -> Ty { @@ -35,11 +35,11 @@ impl ImplBlock { } pub fn items(&self, db: &impl DefDatabase) -> Vec { - db.impl_data(self.id).items().iter().map(|it| (*it).into()).collect() + db.impl_data(self.id).items.iter().map(|it| (*it).into()).collect() } pub fn is_negative(&self, db: &impl DefDatabase) -> bool { - db.impl_data(self.id).is_negative() + db.impl_data(self.id).is_negative } pub fn module(&self, db: &impl DefDatabase) -> Module { diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index 41a51283d..6e07ab86e 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -22,7 +22,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue}; use rustc_hash::FxHashMap; use hir_def::{ - function::FunctionData, + data::FunctionData, path::known, resolver::{HasResolver, Resolver, TypeNs}, type_ref::{Mutability, TypeRef}, 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