84 lines
2.6 KiB
Rust
84 lines
2.6 KiB
Rust
//! Temp module to wrap hir_def::generics
|
|
use std::sync::Arc;
|
|
|
|
use crate::{
|
|
db::{AstDatabase, DefDatabase, HirDatabase},
|
|
Adt, Const, Container, Enum, EnumVariant, Function, ImplBlock, Struct, Trait, TypeAlias, Union,
|
|
};
|
|
|
|
pub use hir_def::generics::{GenericParam, GenericParams, WherePredicate};
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
|
|
pub enum GenericDef {
|
|
Function(Function),
|
|
Adt(Adt),
|
|
Trait(Trait),
|
|
TypeAlias(TypeAlias),
|
|
ImplBlock(ImplBlock),
|
|
// enum variants cannot have generics themselves, but their parent enums
|
|
// can, and this makes some code easier to write
|
|
EnumVariant(EnumVariant),
|
|
// consts can have type parameters from their parents (i.e. associated consts of traits)
|
|
Const(Const),
|
|
}
|
|
impl_froms!(
|
|
GenericDef: Function,
|
|
Adt(Struct, Enum, Union),
|
|
Trait,
|
|
TypeAlias,
|
|
ImplBlock,
|
|
EnumVariant,
|
|
Const
|
|
);
|
|
|
|
pub(crate) fn generic_params_query(
|
|
db: &(impl DefDatabase + AstDatabase),
|
|
def: GenericDef,
|
|
) -> Arc<GenericParams> {
|
|
let parent = match def {
|
|
GenericDef::Function(it) => it.container(db).map(GenericDef::from),
|
|
GenericDef::TypeAlias(it) => it.container(db).map(GenericDef::from),
|
|
GenericDef::Const(it) => it.container(db).map(GenericDef::from),
|
|
GenericDef::EnumVariant(it) => Some(it.parent_enum(db).into()),
|
|
GenericDef::Adt(_) | GenericDef::Trait(_) => None,
|
|
GenericDef::ImplBlock(_) => None,
|
|
};
|
|
Arc::new(GenericParams::new(db, def.into(), parent.map(|it| db.generic_params(it))))
|
|
}
|
|
|
|
impl GenericDef {
|
|
pub(crate) fn resolver(&self, db: &impl HirDatabase) -> crate::Resolver {
|
|
match self {
|
|
GenericDef::Function(inner) => inner.resolver(db),
|
|
GenericDef::Adt(adt) => adt.resolver(db),
|
|
GenericDef::Trait(inner) => inner.resolver(db),
|
|
GenericDef::TypeAlias(inner) => inner.resolver(db),
|
|
GenericDef::ImplBlock(inner) => inner.resolver(db),
|
|
GenericDef::EnumVariant(inner) => inner.parent_enum(db).resolver(db),
|
|
GenericDef::Const(inner) => inner.resolver(db),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Container> for GenericDef {
|
|
fn from(c: Container) -> Self {
|
|
match c {
|
|
Container::Trait(trait_) => trait_.into(),
|
|
Container::ImplBlock(impl_block) => impl_block.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait HasGenericParams: Copy {
|
|
fn generic_params(self, db: &impl DefDatabase) -> Arc<GenericParams>;
|
|
}
|
|
|
|
impl<T> HasGenericParams for T
|
|
where
|
|
T: Into<GenericDef> + Copy,
|
|
{
|
|
fn generic_params(self, db: &impl DefDatabase) -> Arc<GenericParams> {
|
|
db.generic_params(self.into())
|
|
}
|
|
}
|