attr::{Attrs, Documentation},
path::ModPath,
resolver::HasResolver,
- AttrDefId, ModuleDefId,
+ AttrDefId, GenericParamId, ModuleDefId,
};
use hir_expand::hygiene::Hygiene;
use hir_ty::db::HirDatabase;
use syntax::ast;
use crate::{
- Adt, Const, Enum, Field, Function, MacroDef, Module, ModuleDef, Static, Struct, Trait,
- TypeAlias, Union, Variant,
+ Adt, Const, Enum, Field, Function, GenericParam, MacroDef, Module, ModuleDef, Static, Struct,
+ Trait, TypeAlias, Union, Variant,
};
pub trait HasAttrs {
(Function, FunctionId),
(Adt, AdtId),
(Module, ModuleId),
+ (GenericParam, GenericParamId),
];
macro_rules! impl_has_attrs_adt {
AttrDefId::TraitId(it) => it.resolver(db.upcast()),
AttrDefId::TypeAliasId(it) => it.resolver(db.upcast()),
AttrDefId::ImplId(it) => it.resolver(db.upcast()),
+ AttrDefId::GenericParamId(it) => match it {
+ GenericParamId::TypeParamId(it) => it.parent,
+ GenericParamId::LifetimeParamId(it) => it.parent,
+ GenericParamId::ConstParamId(it) => it.parent,
+ }
+ .resolver(db.upcast()),
AttrDefId::MacroDefId(_) => return None,
};
let path = ast::Path::parse(link).ok()?;
use hir_def::{
expr::{LabelId, PatId},
item_scope::ItemInNs,
- AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId, ModuleDefId,
- VariantId,
+ AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId, GenericParamId,
+ ModuleDefId, VariantId,
};
use crate::{
- Adt, AssocItem, DefWithBody, Field, GenericDef, Label, Local, MacroDef, ModuleDef, Variant,
- VariantDef,
+ code_model::GenericParam, Adt, AssocItem, DefWithBody, Field, GenericDef, Label, Local,
+ MacroDef, ModuleDef, Variant, VariantDef,
};
macro_rules! from_id {
}
}
+impl From<GenericParamId> for GenericParam {
+ fn from(id: GenericParamId) -> Self {
+ match id {
+ GenericParamId::TypeParamId(it) => GenericParam::TypeParam(it.into()),
+ GenericParamId::LifetimeParamId(it) => GenericParam::LifetimeParam(it.into()),
+ GenericParamId::ConstParamId(it) => GenericParam::ConstParam(it.into()),
+ }
+ }
+}
+
+impl From<GenericParam> for GenericParamId {
+ fn from(id: GenericParam) -> Self {
+ match id {
+ GenericParam::TypeParam(it) => GenericParamId::TypeParamId(it.id),
+ GenericParam::LifetimeParam(it) => GenericParamId::LifetimeParamId(it.id),
+ GenericParam::ConstParam(it) => GenericParamId::ConstParamId(it.id),
+ }
+ }
+}
+
impl From<EnumVariantId> for Variant {
fn from(id: EnumVariantId) -> Self {
Variant { parent: id.parent.into(), id: id.local_id }
code_model::{
Access, Adt, AsAssocItem, AssocItem, AssocItemContainer, Callable, CallableKind, Const,
ConstParam, Crate, CrateDependency, DefWithBody, Enum, Field, FieldSource, Function,
- GenericDef, HasVisibility, Impl, Label, LifetimeParam, Local, MacroDef, Module, ModuleDef,
- ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+ GenericDef, GenericParam, HasVisibility, Impl, Label, LifetimeParam, Local, MacroDef,
+ Module, ModuleDef, ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union,
+ Variant, VariantDef,
},
has_source::HasSource,
semantics::{PathResolution, Semantics, SemanticsScope},
nameres::ModuleSource,
path::{ModPath, PathKind},
src::HasChildSource,
- AdtId, AttrDefId, Lookup,
+ AdtId, AttrDefId, GenericParamId, Lookup,
};
/// Holds documentation
AttrDefId::StaticId(it) => attrs_from_item_tree(it.lookup(db).id, db),
AttrDefId::FunctionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
AttrDefId::TypeAliasId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+ AttrDefId::GenericParamId(it) => match it {
+ GenericParamId::TypeParamId(it) => {
+ let src = it.parent.child_source(db);
+ RawAttrs::from_attrs_owner(
+ db,
+ src.with_value(
+ src.value[it.local_id].as_ref().either(|it| it as _, |it| it as _),
+ ),
+ )
+ }
+ GenericParamId::LifetimeParamId(it) => {
+ let src = it.parent.child_source(db);
+ RawAttrs::from_attrs_owner(db, src.with_value(&src.value[it.local_id]))
+ }
+ GenericParamId::ConstParamId(it) => {
+ let src = it.parent.child_source(db);
+ RawAttrs::from_attrs_owner(db, src.with_value(&src.value[it.local_id]))
+ }
+ },
};
raw_attrs.filter(db, def.krate(db))
}
impl_from!(StructId, UnionId, EnumId for AdtId);
+/// A generic param
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum GenericParamId {
+ TypeParamId(TypeParamId),
+ LifetimeParamId(LifetimeParamId),
+ ConstParamId(ConstParamId),
+}
+impl_from!(TypeParamId, LifetimeParamId, ConstParamId for GenericParamId);
+
/// The defs which can be visible in the module.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ModuleDefId {
TypeAliasId(TypeAliasId),
MacroDefId(MacroDefId),
ImplId(ImplId),
+ GenericParamId(GenericParamId),
}
impl_from!(
TraitId,
TypeAliasId,
MacroDefId,
- ImplId
+ ImplId,
+ GenericParamId
for AttrDefId
);
AttrDefId::TraitId(it) => it.lookup(db).container.module(db).krate,
AttrDefId::TypeAliasId(it) => it.lookup(db).module(db).krate,
AttrDefId::ImplId(it) => it.lookup(db).container.module(db).krate,
+ AttrDefId::GenericParamId(it) => {
+ match it {
+ GenericParamId::TypeParamId(it) => it.parent,
+ GenericParamId::LifetimeParamId(it) => it.parent,
+ GenericParamId::ConstParamId(it) => it.parent,
+ }
+ .module(db)
+ .krate
+ }
// FIXME: `MacroDefId` should store the defining module, then this can implement
// `HasModule`
AttrDefId::MacroDefId(it) => it.krate,