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, BuiltinDeriveImplId, DefWithBodyId, EnumVariantId, ExpressionStoreOwnerId,
8    FieldId, FunctionId, GenericDefId, GenericParamId, ImplId, ModuleDefId, VariantId,
9    hir::{BindingId, LabelId},
10};
11use hir_ty::next_solver::AnyImplId;
12
13use crate::{
14    Adt, AnyFunctionId, AssocItem, BuiltinType, DefWithBody, EnumVariant, ExpressionStoreOwner,
15    Field, Function, GenericDef, GenericParam, Impl, ItemInNs, Label, Local, ModuleDef, Variant,
16};
17
18macro_rules! from_id {
19    ($(($id:path, $ty:path)),* $(,)?) => {$(
20        impl From<$id> for $ty {
21            fn from(id: $id) -> $ty {
22                $ty { id }
23            }
24        }
25        impl From<$ty> for $id {
26            fn from(ty: $ty) -> $id {
27                ty.id
28            }
29        }
30    )*}
31}
32
33from_id![
34    (base_db::Crate, crate::Crate),
35    (hir_def::ModuleId, crate::Module),
36    (hir_def::StructId, crate::Struct),
37    (hir_def::UnionId, crate::Union),
38    (hir_def::EnumId, crate::Enum),
39    (hir_def::TypeAliasId, crate::TypeAlias),
40    (hir_def::TraitId, crate::Trait),
41    (hir_def::StaticId, crate::Static),
42    (hir_def::ConstId, crate::Const),
43    (crate::AnyFunctionId, crate::Function),
44    (hir_ty::next_solver::AnyImplId, crate::Impl),
45    (hir_def::TypeOrConstParamId, crate::TypeOrConstParam),
46    (hir_def::TypeParamId, crate::TypeParam),
47    (hir_def::ConstParamId, crate::ConstParam),
48    (hir_def::LifetimeParamId, crate::LifetimeParam),
49    (hir_def::MacroId, crate::Macro),
50    (hir_def::ExternCrateId, crate::ExternCrateDecl),
51    (hir_def::ExternBlockId, crate::ExternBlock),
52];
53
54impl From<AdtId> for Adt {
55    fn from(id: AdtId) -> Self {
56        match id {
57            AdtId::StructId(it) => Adt::Struct(it.into()),
58            AdtId::UnionId(it) => Adt::Union(it.into()),
59            AdtId::EnumId(it) => Adt::Enum(it.into()),
60        }
61    }
62}
63
64impl From<Adt> for AdtId {
65    fn from(id: Adt) -> Self {
66        match id {
67            Adt::Struct(it) => AdtId::StructId(it.id),
68            Adt::Union(it) => AdtId::UnionId(it.id),
69            Adt::Enum(it) => AdtId::EnumId(it.id),
70        }
71    }
72}
73
74impl From<VariantId> for Variant {
75    fn from(v: VariantId) -> Self {
76        match v {
77            VariantId::EnumVariantId(it) => Variant::EnumVariant(it.into()),
78            VariantId::StructId(it) => Variant::Struct(it.into()),
79            VariantId::UnionId(it) => Variant::Union(it.into()),
80        }
81    }
82}
83impl From<GenericParamId> for GenericParam {
84    fn from(id: GenericParamId) -> Self {
85        match id {
86            GenericParamId::TypeParamId(it) => GenericParam::TypeParam(it.into()),
87            GenericParamId::ConstParamId(it) => GenericParam::ConstParam(it.into()),
88            GenericParamId::LifetimeParamId(it) => GenericParam::LifetimeParam(it.into()),
89        }
90    }
91}
92
93impl From<GenericParam> for GenericParamId {
94    fn from(id: GenericParam) -> Self {
95        match id {
96            GenericParam::LifetimeParam(it) => GenericParamId::LifetimeParamId(it.id),
97            GenericParam::ConstParam(it) => GenericParamId::ConstParamId(it.id),
98            GenericParam::TypeParam(it) => GenericParamId::TypeParamId(it.id),
99        }
100    }
101}
102
103impl From<EnumVariantId> for EnumVariant {
104    fn from(id: EnumVariantId) -> Self {
105        EnumVariant { id }
106    }
107}
108
109impl From<EnumVariant> for EnumVariantId {
110    fn from(def: EnumVariant) -> Self {
111        def.id
112    }
113}
114
115impl From<ModuleDefId> for ModuleDef {
116    fn from(id: ModuleDefId) -> Self {
117        match id {
118            ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
119            ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
120            ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
121            ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
122            ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
123            ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
124            ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
125            ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
126            ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it.into()),
127            ModuleDefId::MacroId(it) => ModuleDef::Macro(it.into()),
128        }
129    }
130}
131
132impl TryFrom<ModuleDef> for ModuleDefId {
133    type Error = ();
134    fn try_from(id: ModuleDef) -> Result<Self, Self::Error> {
135        Ok(match id {
136            ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
137            ModuleDef::Function(it) => match it.id {
138                AnyFunctionId::FunctionId(it) => it.into(),
139                AnyFunctionId::BuiltinDeriveImplMethod { .. } => return Err(()),
140            },
141            ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
142            ModuleDef::EnumVariant(it) => ModuleDefId::EnumVariantId(it.into()),
143            ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
144            ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
145            ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
146            ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
147            ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()),
148            ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()),
149        })
150    }
151}
152
153impl TryFrom<DefWithBody> for DefWithBodyId {
154    type Error = ();
155    fn try_from(def: DefWithBody) -> Result<Self, ()> {
156        Ok(match def {
157            DefWithBody::Function(it) => match it.id {
158                AnyFunctionId::FunctionId(it) => it.into(),
159                AnyFunctionId::BuiltinDeriveImplMethod { .. } => return Err(()),
160            },
161            DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),
162            DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),
163            DefWithBody::EnumVariant(it) => DefWithBodyId::VariantId(it.into()),
164        })
165    }
166}
167
168impl From<DefWithBodyId> for DefWithBody {
169    fn from(def: DefWithBodyId) -> Self {
170        match def {
171            DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
172            DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
173            DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
174            DefWithBodyId::VariantId(it) => DefWithBody::EnumVariant(it.into()),
175        }
176    }
177}
178
179impl From<AssocItemId> for AssocItem {
180    fn from(def: AssocItemId) -> Self {
181        match def {
182            AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
183            AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
184            AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
185        }
186    }
187}
188
189impl TryFrom<GenericDef> for GenericDefId {
190    type Error = ();
191
192    fn try_from(def: GenericDef) -> Result<Self, Self::Error> {
193        def.id().ok_or(())
194    }
195}
196
197impl From<GenericDefId> for GenericDef {
198    fn from(def: GenericDefId) -> Self {
199        match def {
200            GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
201            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
202            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
203            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
204            GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
205            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
206            GenericDefId::StaticId(it) => GenericDef::Static(it.into()),
207        }
208    }
209}
210
211impl From<Adt> for GenericDefId {
212    fn from(id: Adt) -> Self {
213        match id {
214            Adt::Struct(it) => it.id.into(),
215            Adt::Union(it) => it.id.into(),
216            Adt::Enum(it) => it.id.into(),
217        }
218    }
219}
220
221impl From<Variant> for VariantId {
222    fn from(def: Variant) -> Self {
223        match def {
224            Variant::Struct(it) => VariantId::StructId(it.id),
225            Variant::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
226            Variant::Union(it) => VariantId::UnionId(it.id),
227        }
228    }
229}
230
231impl From<Field> for FieldId {
232    fn from(def: Field) -> Self {
233        FieldId { parent: def.parent.into(), local_id: def.id }
234    }
235}
236
237impl From<FieldId> for Field {
238    fn from(def: FieldId) -> Self {
239        Field { parent: def.parent.into(), id: def.local_id }
240    }
241}
242
243impl TryFrom<AssocItem> for GenericDefId {
244    type Error = ();
245    fn try_from(item: AssocItem) -> Result<Self, Self::Error> {
246        Ok(match item {
247            AssocItem::Function(f) => match f.id {
248                AnyFunctionId::FunctionId(it) => it.into(),
249                AnyFunctionId::BuiltinDeriveImplMethod { .. } => return Err(()),
250            },
251            AssocItem::Const(c) => c.id.into(),
252            AssocItem::TypeAlias(t) => t.id.into(),
253        })
254    }
255}
256
257impl From<(DefWithBodyId, BindingId)> for Local {
258    fn from((parent, binding_id): (DefWithBodyId, BindingId)) -> Self {
259        Local { parent: parent.into(), parent_infer: parent.into(), binding_id }
260    }
261}
262
263impl From<(ExpressionStoreOwnerId, LabelId)> for Label {
264    fn from((parent, label_id): (ExpressionStoreOwnerId, LabelId)) -> Self {
265        Label { parent, label_id }
266    }
267}
268
269impl From<hir_def::item_scope::ItemInNs> for ItemInNs {
270    fn from(it: hir_def::item_scope::ItemInNs) -> Self {
271        match it {
272            hir_def::item_scope::ItemInNs::Types(it) => ItemInNs::Types(it.into()),
273            hir_def::item_scope::ItemInNs::Values(it) => ItemInNs::Values(it.into()),
274            hir_def::item_scope::ItemInNs::Macros(it) => ItemInNs::Macros(it.into()),
275        }
276    }
277}
278
279impl TryFrom<ItemInNs> for hir_def::item_scope::ItemInNs {
280    type Error = ();
281    fn try_from(it: ItemInNs) -> Result<Self, Self::Error> {
282        Ok(match it {
283            ItemInNs::Types(it) => Self::Types(it.try_into()?),
284            ItemInNs::Values(it) => Self::Values(it.try_into()?),
285            ItemInNs::Macros(it) => Self::Macros(it.into()),
286        })
287    }
288}
289
290impl From<hir_def::builtin_type::BuiltinType> for BuiltinType {
291    fn from(inner: hir_def::builtin_type::BuiltinType) -> Self {
292        Self { inner }
293    }
294}
295
296impl From<BuiltinType> for hir_def::builtin_type::BuiltinType {
297    fn from(it: BuiltinType) -> Self {
298        it.inner
299    }
300}
301
302impl From<hir_def::ImplId> for crate::Impl {
303    fn from(value: hir_def::ImplId) -> Self {
304        crate::Impl { id: AnyImplId::ImplId(value) }
305    }
306}
307
308impl From<BuiltinDeriveImplId> for crate::Impl {
309    fn from(value: BuiltinDeriveImplId) -> Self {
310        crate::Impl { id: AnyImplId::BuiltinDeriveImplId(value) }
311    }
312}
313
314impl From<hir_def::FunctionId> for crate::Function {
315    fn from(value: hir_def::FunctionId) -> Self {
316        crate::Function { id: AnyFunctionId::FunctionId(value) }
317    }
318}
319
320impl TryFrom<ExpressionStoreOwner> for ExpressionStoreOwnerId {
321    type Error = ();
322
323    fn try_from(v: ExpressionStoreOwner) -> Result<Self, Self::Error> {
324        match v {
325            ExpressionStoreOwner::Signature(generic_def_id) => {
326                Ok(Self::Signature(generic_def_id.try_into()?))
327            }
328            ExpressionStoreOwner::Body(def_with_body_id) => {
329                Ok(Self::Body(def_with_body_id.try_into()?))
330            }
331            ExpressionStoreOwner::VariantFields(variant_id) => {
332                Ok(Self::VariantFields(variant_id.into()))
333            }
334        }
335    }
336}
337
338impl TryFrom<Function> for FunctionId {
339    type Error = ();
340
341    fn try_from(v: Function) -> Result<Self, Self::Error> {
342        match v.id {
343            AnyFunctionId::FunctionId(id) => Ok(id),
344            _ => Err(()),
345        }
346    }
347}
348
349impl TryFrom<Impl> for ImplId {
350    type Error = ();
351
352    fn try_from(v: Impl) -> Result<Self, Self::Error> {
353        match v.id {
354            AnyImplId::ImplId(id) => Ok(id),
355            _ => Err(()),
356        }
357    }
358}
hir/from_id.rs

hir/
from_id.rs
