hir/
from_id.rs

1//! Utility module for converting between hir_def ids and code_model wrappers.
2//!
3//! It's unclear if we need this long-term, but it's definitely useful while we
4//! are splitting the hir.
5
6use hir_def::{
7    AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId, GenericParamId,
8    ModuleDefId, VariantId,
9    hir::{BindingId, LabelId},
10};
11
12use crate::{
13    Adt, AssocItem, BuiltinType, DefWithBody, Field, GenericDef, GenericParam, ItemInNs, Label,
14    Local, ModuleDef, Variant, VariantDef,
15};
16
17macro_rules! from_id {
18    ($(($id:path, $ty:path)),* $(,)?) => {$(
19        impl From<$id> for $ty {
20            fn from(id: $id) -> $ty {
21                $ty { id }
22            }
23        }
24        impl From<$ty> for $id {
25            fn from(ty: $ty) -> $id {
26                ty.id
27            }
28        }
29    )*}
30}
31
32from_id![
33    (base_db::Crate, crate::Crate),
34    (hir_def::ModuleId, crate::Module),
35    (hir_def::StructId, crate::Struct),
36    (hir_def::UnionId, crate::Union),
37    (hir_def::EnumId, crate::Enum),
38    (hir_def::TypeAliasId, crate::TypeAlias),
39    (hir_def::TraitId, crate::Trait),
40    (hir_def::StaticId, crate::Static),
41    (hir_def::ConstId, crate::Const),
42    (hir_def::FunctionId, crate::Function),
43    (hir_def::ImplId, crate::Impl),
44    (hir_def::TypeOrConstParamId, crate::TypeOrConstParam),
45    (hir_def::TypeParamId, crate::TypeParam),
46    (hir_def::ConstParamId, crate::ConstParam),
47    (hir_def::LifetimeParamId, crate::LifetimeParam),
48    (hir_def::MacroId, crate::Macro),
49    (hir_def::ExternCrateId, crate::ExternCrateDecl),
50    (hir_def::ExternBlockId, crate::ExternBlock),
51];
52
53impl From<AdtId> for Adt {
54    fn from(id: AdtId) -> Self {
55        match id {
56            AdtId::StructId(it) => Adt::Struct(it.into()),
57            AdtId::UnionId(it) => Adt::Union(it.into()),
58            AdtId::EnumId(it) => Adt::Enum(it.into()),
59        }
60    }
61}
62
63impl From<Adt> for AdtId {
64    fn from(id: Adt) -> Self {
65        match id {
66            Adt::Struct(it) => AdtId::StructId(it.id),
67            Adt::Union(it) => AdtId::UnionId(it.id),
68            Adt::Enum(it) => AdtId::EnumId(it.id),
69        }
70    }
71}
72
73impl From<GenericParamId> for GenericParam {
74    fn from(id: GenericParamId) -> Self {
75        match id {
76            GenericParamId::TypeParamId(it) => GenericParam::TypeParam(it.into()),
77            GenericParamId::ConstParamId(it) => GenericParam::ConstParam(it.into()),
78            GenericParamId::LifetimeParamId(it) => GenericParam::LifetimeParam(it.into()),
79        }
80    }
81}
82
83impl From<GenericParam> for GenericParamId {
84    fn from(id: GenericParam) -> Self {
85        match id {
86            GenericParam::LifetimeParam(it) => GenericParamId::LifetimeParamId(it.id),
87            GenericParam::ConstParam(it) => GenericParamId::ConstParamId(it.id),
88            GenericParam::TypeParam(it) => GenericParamId::TypeParamId(it.id),
89        }
90    }
91}
92
93impl From<EnumVariantId> for Variant {
94    fn from(id: EnumVariantId) -> Self {
95        Variant { id }
96    }
97}
98
99impl From<Variant> for EnumVariantId {
100    fn from(def: Variant) -> Self {
101        def.id
102    }
103}
104
105impl From<ModuleDefId> for ModuleDef {
106    fn from(id: ModuleDefId) -> Self {
107        match id {
108            ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
109            ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
110            ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
111            ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
112            ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
113            ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
114            ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
115            ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
116            ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it.into()),
117            ModuleDefId::MacroId(it) => ModuleDef::Macro(it.into()),
118        }
119    }
120}
121
122impl From<ModuleDef> for ModuleDefId {
123    fn from(id: ModuleDef) -> Self {
124        match id {
125            ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
126            ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
127            ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
128            ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
129            ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
130            ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
131            ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
132            ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
133            ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()),
134            ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()),
135        }
136    }
137}
138
139impl From<DefWithBody> for DefWithBodyId {
140    fn from(def: DefWithBody) -> Self {
141        match def {
142            DefWithBody::Function(it) => DefWithBodyId::FunctionId(it.id),
143            DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),
144            DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),
145            DefWithBody::Variant(it) => DefWithBodyId::VariantId(it.into()),
146        }
147    }
148}
149
150impl From<DefWithBodyId> for DefWithBody {
151    fn from(def: DefWithBodyId) -> Self {
152        match def {
153            DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
154            DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
155            DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
156            DefWithBodyId::VariantId(it) => DefWithBody::Variant(it.into()),
157        }
158    }
159}
160
161impl From<AssocItemId> for AssocItem {
162    fn from(def: AssocItemId) -> Self {
163        match def {
164            AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
165            AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
166            AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
167        }
168    }
169}
170
171impl From<GenericDef> for GenericDefId {
172    fn from(def: GenericDef) -> Self {
173        match def {
174            GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
175            GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
176            GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
177            GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
178            GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
179            GenericDef::Const(it) => GenericDefId::ConstId(it.id),
180            GenericDef::Static(it) => GenericDefId::StaticId(it.id),
181        }
182    }
183}
184
185impl From<GenericDefId> for GenericDef {
186    fn from(def: GenericDefId) -> Self {
187        match def {
188            GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
189            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
190            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
191            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
192            GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
193            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
194            GenericDefId::StaticId(it) => GenericDef::Static(it.into()),
195        }
196    }
197}
198
199impl From<Adt> for GenericDefId {
200    fn from(id: Adt) -> Self {
201        match id {
202            Adt::Struct(it) => it.id.into(),
203            Adt::Union(it) => it.id.into(),
204            Adt::Enum(it) => it.id.into(),
205        }
206    }
207}
208
209impl From<VariantId> for VariantDef {
210    fn from(def: VariantId) -> Self {
211        match def {
212            VariantId::StructId(it) => VariantDef::Struct(it.into()),
213            VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()),
214            VariantId::UnionId(it) => VariantDef::Union(it.into()),
215        }
216    }
217}
218
219impl From<VariantDef> for VariantId {
220    fn from(def: VariantDef) -> Self {
221        match def {
222            VariantDef::Struct(it) => VariantId::StructId(it.id),
223            VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()),
224            VariantDef::Union(it) => VariantId::UnionId(it.id),
225        }
226    }
227}
228
229impl From<Field> for FieldId {
230    fn from(def: Field) -> Self {
231        FieldId { parent: def.parent.into(), local_id: def.id }
232    }
233}
234
235impl From<FieldId> for Field {
236    fn from(def: FieldId) -> Self {
237        Field { parent: def.parent.into(), id: def.local_id }
238    }
239}
240
241impl From<AssocItem> for GenericDefId {
242    fn from(item: AssocItem) -> Self {
243        match item {
244            AssocItem::Function(f) => f.id.into(),
245            AssocItem::Const(c) => c.id.into(),
246            AssocItem::TypeAlias(t) => t.id.into(),
247        }
248    }
249}
250
251impl From<(DefWithBodyId, BindingId)> for Local {
252    fn from((parent, binding_id): (DefWithBodyId, BindingId)) -> Self {
253        Local { parent, binding_id }
254    }
255}
256
257impl From<(DefWithBodyId, LabelId)> for Label {
258    fn from((parent, label_id): (DefWithBodyId, LabelId)) -> Self {
259        Label { parent, label_id }
260    }
261}
262
263impl From<hir_def::item_scope::ItemInNs> for ItemInNs {
264    fn from(it: hir_def::item_scope::ItemInNs) -> Self {
265        match it {
266            hir_def::item_scope::ItemInNs::Types(it) => ItemInNs::Types(it.into()),
267            hir_def::item_scope::ItemInNs::Values(it) => ItemInNs::Values(it.into()),
268            hir_def::item_scope::ItemInNs::Macros(it) => ItemInNs::Macros(it.into()),
269        }
270    }
271}
272
273impl From<ItemInNs> for hir_def::item_scope::ItemInNs {
274    fn from(it: ItemInNs) -> Self {
275        match it {
276            ItemInNs::Types(it) => Self::Types(it.into()),
277            ItemInNs::Values(it) => Self::Values(it.into()),
278            ItemInNs::Macros(it) => Self::Macros(it.into()),
279        }
280    }
281}
282
283impl From<hir_def::builtin_type::BuiltinType> for BuiltinType {
284    fn from(inner: hir_def::builtin_type::BuiltinType) -> Self {
285        Self { inner }
286    }
287}
288
289impl From<BuiltinType> for hir_def::builtin_type::BuiltinType {
290    fn from(it: BuiltinType) -> Self {
291        it.inner
292    }
293}
hir/from_id.rs

hir/
from_id.rs
