2019-11-22 08:33:53 -06:00
|
|
|
//! Contains basic data about various HIR declarations.
|
|
|
|
|
2019-11-22 08:32:10 -06:00
|
|
|
use std::sync::Arc;
|
|
|
|
|
2020-06-22 09:41:10 -05:00
|
|
|
use hir_expand::{name::Name, InFile};
|
2020-08-12 11:26:51 -05:00
|
|
|
use syntax::ast;
|
2019-11-22 08:32:10 -06:00
|
|
|
|
|
|
|
use crate::{
|
2020-04-07 10:58:05 -05:00
|
|
|
attr::Attrs,
|
2020-06-22 08:07:06 -05:00
|
|
|
body::Expander,
|
2019-11-23 05:44:43 -06:00
|
|
|
db::DefDatabase,
|
2021-03-17 10:29:57 -05:00
|
|
|
item_tree::{AssocItem, FunctionQualifier, ItemTreeId, ModItem, Param},
|
2020-06-22 09:41:10 -05:00
|
|
|
type_ref::{TypeBound, TypeRef},
|
2020-03-07 16:03:56 -06:00
|
|
|
visibility::RawVisibility,
|
2020-06-22 08:07:06 -05:00
|
|
|
AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
|
|
|
|
Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
|
2019-11-22 08:32:10 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
|
|
pub struct FunctionData {
|
|
|
|
pub name: Name,
|
|
|
|
pub params: Vec<TypeRef>,
|
|
|
|
pub ret_type: TypeRef,
|
2020-04-07 10:58:05 -05:00
|
|
|
pub attrs: Attrs,
|
2019-11-22 08:32:10 -06:00
|
|
|
/// 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,
|
2020-09-03 02:55:24 -05:00
|
|
|
pub has_body: bool,
|
2021-03-14 05:00:11 -05:00
|
|
|
pub qualifier: FunctionQualifier,
|
|
|
|
pub is_in_extern_block: bool,
|
2020-07-14 11:23:45 -05:00
|
|
|
pub is_varargs: bool,
|
2020-03-07 16:03:56 -06:00
|
|
|
pub visibility: RawVisibility,
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl FunctionData {
|
2020-07-07 03:14:48 -05:00
|
|
|
pub(crate) fn fn_data_query(db: &dyn DefDatabase, func: FunctionId) -> Arc<FunctionData> {
|
2020-03-14 14:48:36 -05:00
|
|
|
let loc = func.lookup(db);
|
2020-12-17 17:23:46 -06:00
|
|
|
let krate = loc.container.module(db).krate;
|
2021-03-17 12:28:00 -05:00
|
|
|
let crate_graph = db.crate_graph();
|
|
|
|
let cfg_options = &crate_graph[krate].cfg_options;
|
2020-06-22 09:41:10 -05:00
|
|
|
let item_tree = db.item_tree(loc.id.file_id);
|
|
|
|
let func = &item_tree[loc.id.value];
|
2021-03-17 12:28:00 -05:00
|
|
|
|
|
|
|
let enabled_params = func
|
2021-03-17 10:29:57 -05:00
|
|
|
.params
|
|
|
|
.clone()
|
2021-03-17 12:28:00 -05:00
|
|
|
.filter(|¶m| item_tree.attrs(db, krate, param.into()).is_cfg_enabled(cfg_options));
|
|
|
|
|
|
|
|
// If last cfg-enabled param is a `...` param, it's a varargs function.
|
|
|
|
let is_varargs = enabled_params
|
|
|
|
.clone()
|
|
|
|
.next_back()
|
2021-03-17 10:29:57 -05:00
|
|
|
.map_or(false, |param| matches!(item_tree[param], Param::Varargs));
|
2020-06-22 09:41:10 -05:00
|
|
|
|
|
|
|
Arc::new(FunctionData {
|
|
|
|
name: func.name.clone(),
|
2021-03-17 12:28:00 -05:00
|
|
|
params: enabled_params
|
2021-03-17 10:29:57 -05:00
|
|
|
.clone()
|
|
|
|
.filter_map(|id| match &item_tree[id] {
|
|
|
|
Param::Normal(ty) => Some(item_tree[*ty].clone()),
|
|
|
|
Param::Varargs => None,
|
|
|
|
})
|
|
|
|
.collect(),
|
2021-02-04 12:19:51 -06:00
|
|
|
ret_type: item_tree[func.ret_type].clone(),
|
2021-02-05 09:57:26 -06:00
|
|
|
attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
|
2020-06-22 09:41:10 -05:00
|
|
|
has_self_param: func.has_self_param,
|
2020-09-03 02:55:24 -05:00
|
|
|
has_body: func.has_body,
|
2021-03-14 05:00:11 -05:00
|
|
|
qualifier: func.qualifier.clone(),
|
|
|
|
is_in_extern_block: func.is_in_extern_block,
|
2021-03-17 10:29:57 -05:00
|
|
|
is_varargs,
|
2020-06-24 08:36:18 -05:00
|
|
|
visibility: item_tree[func.visibility].clone(),
|
2020-06-22 09:41:10 -05:00
|
|
|
})
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
|
|
pub struct TypeAliasData {
|
|
|
|
pub name: Name,
|
|
|
|
pub type_ref: Option<TypeRef>,
|
2020-03-08 09:11:57 -05:00
|
|
|
pub visibility: RawVisibility,
|
2020-09-16 07:57:14 -05:00
|
|
|
pub is_extern: bool,
|
2020-06-22 09:41:10 -05:00
|
|
|
/// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
|
2020-04-12 05:28:24 -05:00
|
|
|
pub bounds: Vec<TypeBound>,
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TypeAliasData {
|
|
|
|
pub(crate) fn type_alias_data_query(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn DefDatabase,
|
2019-11-22 08:32:10 -06:00
|
|
|
typ: TypeAliasId,
|
|
|
|
) -> Arc<TypeAliasData> {
|
2020-03-14 14:48:36 -05:00
|
|
|
let loc = typ.lookup(db);
|
2020-06-22 09:41:10 -05:00
|
|
|
let item_tree = db.item_tree(loc.id.file_id);
|
|
|
|
let typ = &item_tree[loc.id.value];
|
|
|
|
|
|
|
|
Arc::new(TypeAliasData {
|
|
|
|
name: typ.name.clone(),
|
2021-02-04 12:19:51 -06:00
|
|
|
type_ref: typ.type_ref.map(|id| item_tree[id].clone()),
|
2020-06-24 08:36:18 -05:00
|
|
|
visibility: item_tree[typ.visibility].clone(),
|
2020-09-16 07:57:14 -05:00
|
|
|
is_extern: typ.is_extern,
|
2020-06-24 09:07:02 -05:00
|
|
|
bounds: typ.bounds.to_vec(),
|
2020-06-22 09:41:10 -05:00
|
|
|
})
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
|
|
pub struct TraitData {
|
2019-11-27 14:22:20 -06:00
|
|
|
pub name: Name,
|
2019-11-26 08:12:16 -06:00
|
|
|
pub items: Vec<(Name, AssocItemId)>,
|
2021-03-15 11:05:03 -05:00
|
|
|
pub is_auto: bool,
|
|
|
|
pub is_unsafe: bool,
|
|
|
|
pub visibility: RawVisibility,
|
|
|
|
pub bounds: Box<[TypeBound]>,
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TraitData {
|
2020-03-13 10:05:46 -05:00
|
|
|
pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
|
2020-05-03 09:08:39 -05:00
|
|
|
let tr_loc = tr.lookup(db);
|
2020-06-22 08:07:06 -05:00
|
|
|
let item_tree = db.item_tree(tr_loc.id.file_id);
|
|
|
|
let tr_def = &item_tree[tr_loc.id.value];
|
|
|
|
let name = tr_def.name.clone();
|
2021-03-15 11:05:03 -05:00
|
|
|
let is_auto = tr_def.is_auto;
|
|
|
|
let is_unsafe = tr_def.is_unsafe;
|
2021-03-09 12:09:02 -06:00
|
|
|
let module_id = tr_loc.container;
|
2019-12-20 04:59:50 -06:00
|
|
|
let container = AssocContainerId::TraitId(tr);
|
2020-06-22 08:07:06 -05:00
|
|
|
let mut expander = Expander::new(db, tr_loc.id.file_id, module_id);
|
2021-03-15 11:05:03 -05:00
|
|
|
let visibility = item_tree[tr_def.visibility].clone();
|
|
|
|
let bounds = tr_def.bounds.clone();
|
2020-06-22 08:07:06 -05:00
|
|
|
|
|
|
|
let items = collect_items(
|
|
|
|
db,
|
|
|
|
module_id,
|
|
|
|
&mut expander,
|
|
|
|
tr_def.items.iter().copied(),
|
|
|
|
tr_loc.id.file_id,
|
|
|
|
container,
|
|
|
|
100,
|
|
|
|
);
|
|
|
|
|
2021-03-15 11:05:03 -05:00
|
|
|
Arc::new(TraitData { name, items, is_auto, is_unsafe, visibility, bounds })
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
|
2019-11-26 08:12:16 -06:00
|
|
|
self.items.iter().filter_map(|(_name, item)| match item {
|
2019-11-22 08:32:10 -06:00
|
|
|
AssocItemId::TypeAliasId(t) => Some(*t),
|
|
|
|
_ => None,
|
|
|
|
})
|
|
|
|
}
|
2019-11-26 08:12:16 -06:00
|
|
|
|
|
|
|
pub fn associated_type_by_name(&self, name: &Name) -> Option<TypeAliasId> {
|
|
|
|
self.items.iter().find_map(|(item_name, item)| match item {
|
|
|
|
AssocItemId::TypeAliasId(t) if item_name == name => Some(*t),
|
|
|
|
_ => None,
|
|
|
|
})
|
|
|
|
}
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
|
|
pub struct ImplData {
|
2019-11-22 08:33:53 -06:00
|
|
|
pub target_trait: Option<TypeRef>,
|
|
|
|
pub target_type: TypeRef,
|
|
|
|
pub items: Vec<AssocItemId>,
|
|
|
|
pub is_negative: bool,
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl ImplData {
|
2020-03-13 10:05:46 -05:00
|
|
|
pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData> {
|
2020-08-12 09:32:36 -05:00
|
|
|
let _p = profile::span("impl_data_query");
|
2019-12-20 13:37:03 -06:00
|
|
|
let impl_loc = id.lookup(db);
|
2019-11-22 08:32:10 -06:00
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
let item_tree = db.item_tree(impl_loc.id.file_id);
|
|
|
|
let impl_def = &item_tree[impl_loc.id.value];
|
2021-02-04 12:19:51 -06:00
|
|
|
let target_trait = impl_def.target_trait.map(|id| item_tree[id].clone());
|
|
|
|
let target_type = item_tree[impl_def.target_type].clone();
|
2020-06-22 08:07:06 -05:00
|
|
|
let is_negative = impl_def.is_negative;
|
2021-03-09 12:09:02 -06:00
|
|
|
let module_id = impl_loc.container;
|
2020-05-03 09:08:39 -05:00
|
|
|
let container = AssocContainerId::ImplId(id);
|
2020-06-22 08:07:06 -05:00
|
|
|
let mut expander = Expander::new(db, impl_loc.id.file_id, module_id);
|
2019-11-22 08:32:10 -06:00
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
let items = collect_items(
|
|
|
|
db,
|
|
|
|
module_id,
|
|
|
|
&mut expander,
|
|
|
|
impl_def.items.iter().copied(),
|
|
|
|
impl_loc.id.file_id,
|
|
|
|
container,
|
|
|
|
100,
|
|
|
|
);
|
|
|
|
let items = items.into_iter().map(|(_, item)| item).collect();
|
2019-11-22 08:32:10 -06:00
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
Arc::new(ImplData { target_trait, target_type, items, is_negative })
|
2019-11-22 08:32:10 -06:00
|
|
|
}
|
|
|
|
}
|
2019-11-22 09:46:39 -06:00
|
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
|
|
pub struct ConstData {
|
2019-11-27 14:22:20 -06:00
|
|
|
/// const _: () = ();
|
2019-11-22 09:46:39 -06:00
|
|
|
pub name: Option<Name>,
|
|
|
|
pub type_ref: TypeRef,
|
2020-03-08 09:11:57 -05:00
|
|
|
pub visibility: RawVisibility,
|
2019-11-22 09:46:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl ConstData {
|
2020-03-13 10:05:46 -05:00
|
|
|
pub(crate) fn const_data_query(db: &dyn DefDatabase, konst: ConstId) -> Arc<ConstData> {
|
2020-03-14 14:48:36 -05:00
|
|
|
let loc = konst.lookup(db);
|
2020-06-22 09:41:10 -05:00
|
|
|
let item_tree = db.item_tree(loc.id.file_id);
|
|
|
|
let konst = &item_tree[loc.id.value];
|
2019-11-22 09:46:39 -06:00
|
|
|
|
2020-06-22 09:41:10 -05:00
|
|
|
Arc::new(ConstData {
|
|
|
|
name: konst.name.clone(),
|
2021-02-04 12:19:51 -06:00
|
|
|
type_ref: item_tree[konst.type_ref].clone(),
|
2020-06-24 08:36:18 -05:00
|
|
|
visibility: item_tree[konst.visibility].clone(),
|
2020-06-22 09:41:10 -05:00
|
|
|
})
|
2019-11-24 08:34:36 -06:00
|
|
|
}
|
2019-11-22 09:46:39 -06:00
|
|
|
}
|
2019-12-20 13:37:03 -06:00
|
|
|
|
2020-05-10 10:08:28 -05:00
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
|
|
pub struct StaticData {
|
|
|
|
pub name: Option<Name>,
|
|
|
|
pub type_ref: TypeRef,
|
|
|
|
pub visibility: RawVisibility,
|
|
|
|
pub mutable: bool,
|
2020-12-10 08:45:01 -06:00
|
|
|
pub is_extern: bool,
|
2020-05-10 10:08:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
impl StaticData {
|
|
|
|
pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
|
2020-06-22 09:41:10 -05:00
|
|
|
let node = konst.lookup(db);
|
|
|
|
let item_tree = db.item_tree(node.id.file_id);
|
|
|
|
let statik = &item_tree[node.id.value];
|
|
|
|
|
|
|
|
Arc::new(StaticData {
|
|
|
|
name: Some(statik.name.clone()),
|
2021-02-04 12:19:51 -06:00
|
|
|
type_ref: item_tree[statik.type_ref].clone(),
|
2020-06-24 08:36:18 -05:00
|
|
|
visibility: item_tree[statik.visibility].clone(),
|
2020-06-22 09:41:10 -05:00
|
|
|
mutable: statik.mutable,
|
2020-12-10 08:45:01 -06:00
|
|
|
is_extern: statik.is_extern,
|
2020-06-22 09:41:10 -05:00
|
|
|
})
|
2020-05-10 10:08:28 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
fn collect_items(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn DefDatabase,
|
2020-06-22 08:07:06 -05:00
|
|
|
module: ModuleId,
|
2019-12-20 15:02:31 -06:00
|
|
|
expander: &mut Expander,
|
2020-06-22 08:07:06 -05:00
|
|
|
assoc_items: impl Iterator<Item = AssocItem>,
|
|
|
|
file_id: crate::HirFileId,
|
2020-05-03 09:08:39 -05:00
|
|
|
container: AssocContainerId,
|
2019-12-20 15:16:29 -06:00
|
|
|
limit: usize,
|
2020-05-03 09:08:39 -05:00
|
|
|
) -> Vec<(Name, AssocItemId)> {
|
2019-12-20 15:16:29 -06:00
|
|
|
if limit == 0 {
|
|
|
|
return Vec::new();
|
|
|
|
}
|
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
let item_tree = db.item_tree(file_id);
|
|
|
|
let cfg_options = db.crate_graph()[module.krate].cfg_options.clone();
|
2019-12-20 15:02:31 -06:00
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
let mut items = Vec::new();
|
|
|
|
for item in assoc_items {
|
2021-03-17 19:28:40 -05:00
|
|
|
let attrs = item_tree.attrs(db, module.krate, ModItem::from(item).into());
|
|
|
|
if !attrs.is_cfg_enabled(&cfg_options) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-06-22 08:07:06 -05:00
|
|
|
match item {
|
|
|
|
AssocItem::Function(id) => {
|
|
|
|
let item = &item_tree[id];
|
|
|
|
let def = FunctionLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
|
|
|
|
items.push((item.name.clone(), def.into()));
|
2019-12-20 13:37:03 -06:00
|
|
|
}
|
2020-06-22 08:07:06 -05:00
|
|
|
AssocItem::Const(id) => {
|
|
|
|
let item = &item_tree[id];
|
2020-06-23 11:31:14 -05:00
|
|
|
let name = match item.name.clone() {
|
|
|
|
Some(name) => name,
|
|
|
|
None => continue,
|
2020-06-22 08:07:06 -05:00
|
|
|
};
|
|
|
|
let def = ConstLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
|
|
|
|
items.push((name, def.into()));
|
2019-12-20 13:37:03 -06:00
|
|
|
}
|
2020-06-22 08:07:06 -05:00
|
|
|
AssocItem::TypeAlias(id) => {
|
|
|
|
let item = &item_tree[id];
|
|
|
|
let def = TypeAliasLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
|
|
|
|
items.push((item.name.clone(), def.into()));
|
2019-12-20 13:37:03 -06:00
|
|
|
}
|
2020-06-22 08:07:06 -05:00
|
|
|
AssocItem::MacroCall(call) => {
|
|
|
|
let call = &item_tree[call];
|
|
|
|
let ast_id_map = db.ast_id_map(file_id);
|
|
|
|
let root = db.parse_or_expand(file_id).unwrap();
|
|
|
|
let call = ast_id_map.get(call.ast_id).to_node(&root);
|
2021-03-16 02:46:57 -05:00
|
|
|
let res = expander.enter_expand(db, call);
|
|
|
|
|
|
|
|
if let Ok(res) = res {
|
|
|
|
if let Some((mark, mac)) = res.value {
|
|
|
|
let src: InFile<ast::MacroItems> = expander.to_source(mac);
|
|
|
|
let item_tree = db.item_tree(src.file_id);
|
|
|
|
let iter =
|
|
|
|
item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
|
|
|
|
items.extend(collect_items(
|
|
|
|
db,
|
|
|
|
module,
|
|
|
|
expander,
|
|
|
|
iter,
|
|
|
|
src.file_id,
|
|
|
|
container,
|
|
|
|
limit - 1,
|
|
|
|
));
|
|
|
|
|
|
|
|
expander.exit(db, mark);
|
|
|
|
}
|
2020-06-22 08:07:06 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
items
|
2019-12-20 13:37:03 -06:00
|
|
|
}
|