//! are splitting the hir.
use hir_def::{
- expr::PatId, item_scope::ItemInNs, AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId,
- GenericDefId, ModuleDefId, VariantId,
+ expr::{LabelId, PatId},
+ item_scope::ItemInNs,
+ AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId, ModuleDefId,
+ VariantId,
};
use crate::{
- Adt, AssocItem, DefWithBody, EnumVariant, Field, GenericDef, Local, MacroDef, ModuleDef,
+ Adt, AssocItem, DefWithBody, Field, GenericDef, Label, Local, MacroDef, ModuleDef, Variant,
VariantDef,
};
(hir_def::StaticId, crate::Static),
(hir_def::ConstId, crate::Const),
(hir_def::FunctionId, crate::Function),
- (hir_def::ImplId, crate::ImplDef),
+ (hir_def::ImplId, crate::Impl),
(hir_def::TypeParamId, crate::TypeParam),
+ (hir_def::LifetimeParamId, crate::LifetimeParam),
+ (hir_def::ConstParamId, crate::ConstParam),
(hir_expand::MacroDefId, crate::MacroDef)
];
}
}
-impl From<EnumVariantId> for EnumVariant {
+impl From<EnumVariantId> for Variant {
fn from(id: EnumVariantId) -> Self {
- EnumVariant { parent: id.parent.into(), id: id.local_id }
+ Variant { parent: id.parent.into(), id: id.local_id }
}
}
-impl From<EnumVariant> for EnumVariantId {
- fn from(def: EnumVariant) -> Self {
+impl From<Variant> for EnumVariantId {
+ fn from(def: Variant) -> Self {
EnumVariantId { parent: def.parent.id, local_id: def.id }
}
}
ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
- ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
+ ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
- ModuleDef::EnumVariant(it) => ModuleDefId::EnumVariantId(it.into()),
+ ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
- GenericDef::ImplDef(it) => GenericDefId::ImplId(it.id),
- GenericDef::EnumVariant(it) => {
+ GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
+ GenericDef::Variant(it) => {
GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
}
GenericDef::Const(it) => GenericDefId::ConstId(it.id),
}
}
+impl From<GenericDefId> for GenericDef {
+ fn from(def: GenericDefId) -> Self {
+ match def {
+ GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
+ GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
+ GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
+ GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
+ GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
+ GenericDefId::EnumVariantId(it) => {
+ GenericDef::Variant(Variant { parent: it.parent.into(), id: it.local_id })
+ }
+ GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
+ }
+ }
+}
+
impl From<Adt> for GenericDefId {
fn from(id: Adt) -> Self {
match id {
fn from(def: VariantId) -> Self {
match def {
VariantId::StructId(it) => VariantDef::Struct(it.into()),
- VariantId::EnumVariantId(it) => VariantDef::EnumVariant(it.into()),
+ VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()),
VariantId::UnionId(it) => VariantDef::Union(it.into()),
}
}
fn from(def: VariantDef) -> Self {
match def {
VariantDef::Struct(it) => VariantId::StructId(it.id),
- VariantDef::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
+ VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()),
VariantDef::Union(it) => VariantId::UnionId(it.id),
}
}
}
}
+impl From<(DefWithBodyId, LabelId)> for Label {
+ fn from((parent, label_id): (DefWithBodyId, LabelId)) -> Self {
+ Label { parent, label_id }
+ }
+}
+
impl From<MacroDef> for ItemInNs {
fn from(macro_def: MacroDef) -> Self {
ItemInNs::Macros(macro_def.into())