]>
Commit | Line | Data |
---|---|---|
064997fb FG |
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 | ||
6 | use hir_def::{ | |
353b0b11 | 7 | expr::{BindingId, LabelId}, |
064997fb FG |
8 | AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId, GenericParamId, |
9 | ModuleDefId, VariantId, | |
10 | }; | |
11 | ||
12 | use crate::{ | |
13 | Adt, AssocItem, BuiltinType, DefWithBody, Field, GenericDef, GenericParam, ItemInNs, Label, | |
14 | Local, ModuleDef, Variant, VariantDef, | |
15 | }; | |
16 | ||
17 | macro_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 | ||
32 | from_id![ | |
33 | (base_db::CrateId, 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), | |
353b0b11 | 40 | (hir_def::TraitAliasId, crate::TraitAlias), |
064997fb FG |
41 | (hir_def::StaticId, crate::Static), |
42 | (hir_def::ConstId, crate::Const), | |
43 | (hir_def::FunctionId, crate::Function), | |
44 | (hir_def::ImplId, 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 | ]; | |
51 | ||
52 | impl From<AdtId> for Adt { | |
53 | fn from(id: AdtId) -> Self { | |
54 | match id { | |
55 | AdtId::StructId(it) => Adt::Struct(it.into()), | |
56 | AdtId::UnionId(it) => Adt::Union(it.into()), | |
57 | AdtId::EnumId(it) => Adt::Enum(it.into()), | |
58 | } | |
59 | } | |
60 | } | |
61 | ||
62 | impl From<Adt> for AdtId { | |
63 | fn from(id: Adt) -> Self { | |
64 | match id { | |
65 | Adt::Struct(it) => AdtId::StructId(it.id), | |
66 | Adt::Union(it) => AdtId::UnionId(it.id), | |
67 | Adt::Enum(it) => AdtId::EnumId(it.id), | |
68 | } | |
69 | } | |
70 | } | |
71 | ||
72 | impl From<GenericParamId> for GenericParam { | |
73 | fn from(id: GenericParamId) -> Self { | |
74 | match id { | |
75 | GenericParamId::TypeParamId(it) => GenericParam::TypeParam(it.into()), | |
76 | GenericParamId::ConstParamId(it) => GenericParam::ConstParam(it.into()), | |
77 | GenericParamId::LifetimeParamId(it) => GenericParam::LifetimeParam(it.into()), | |
78 | } | |
79 | } | |
80 | } | |
81 | ||
82 | impl From<GenericParam> for GenericParamId { | |
83 | fn from(id: GenericParam) -> Self { | |
84 | match id { | |
85 | GenericParam::LifetimeParam(it) => GenericParamId::LifetimeParamId(it.id), | |
86 | GenericParam::ConstParam(it) => GenericParamId::ConstParamId(it.id), | |
87 | GenericParam::TypeParam(it) => GenericParamId::TypeParamId(it.id), | |
88 | } | |
89 | } | |
90 | } | |
91 | ||
92 | impl From<EnumVariantId> for Variant { | |
93 | fn from(id: EnumVariantId) -> Self { | |
94 | Variant { parent: id.parent.into(), id: id.local_id } | |
95 | } | |
96 | } | |
97 | ||
98 | impl From<Variant> for EnumVariantId { | |
99 | fn from(def: Variant) -> Self { | |
100 | EnumVariantId { parent: def.parent.id, local_id: def.id } | |
101 | } | |
102 | } | |
103 | ||
104 | impl From<ModuleDefId> for ModuleDef { | |
105 | fn from(id: ModuleDefId) -> Self { | |
106 | match id { | |
107 | ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()), | |
108 | ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()), | |
109 | ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()), | |
110 | ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()), | |
111 | ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()), | |
112 | ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()), | |
113 | ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()), | |
353b0b11 | 114 | ModuleDefId::TraitAliasId(it) => ModuleDef::TraitAlias(it.into()), |
064997fb FG |
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 | ||
122 | impl 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()), | |
353b0b11 | 132 | ModuleDef::TraitAlias(it) => ModuleDefId::TraitAliasId(it.into()), |
064997fb FG |
133 | ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()), |
134 | ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()), | |
135 | ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()), | |
136 | } | |
137 | } | |
138 | } | |
139 | ||
140 | impl From<DefWithBody> for DefWithBodyId { | |
141 | fn from(def: DefWithBody) -> Self { | |
142 | match def { | |
143 | DefWithBody::Function(it) => DefWithBodyId::FunctionId(it.id), | |
144 | DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id), | |
145 | DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id), | |
2b03887a | 146 | DefWithBody::Variant(it) => DefWithBodyId::VariantId(it.into()), |
064997fb FG |
147 | } |
148 | } | |
149 | } | |
150 | ||
151 | impl From<DefWithBodyId> for DefWithBody { | |
152 | fn from(def: DefWithBodyId) -> Self { | |
153 | match def { | |
154 | DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()), | |
155 | DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()), | |
156 | DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()), | |
2b03887a | 157 | DefWithBodyId::VariantId(it) => DefWithBody::Variant(it.into()), |
064997fb FG |
158 | } |
159 | } | |
160 | } | |
161 | ||
162 | impl From<AssocItemId> for AssocItem { | |
163 | fn from(def: AssocItemId) -> Self { | |
164 | match def { | |
165 | AssocItemId::FunctionId(it) => AssocItem::Function(it.into()), | |
166 | AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()), | |
167 | AssocItemId::ConstId(it) => AssocItem::Const(it.into()), | |
168 | } | |
169 | } | |
170 | } | |
171 | ||
172 | impl From<GenericDef> for GenericDefId { | |
173 | fn from(def: GenericDef) -> Self { | |
174 | match def { | |
175 | GenericDef::Function(it) => GenericDefId::FunctionId(it.id), | |
176 | GenericDef::Adt(it) => GenericDefId::AdtId(it.into()), | |
177 | GenericDef::Trait(it) => GenericDefId::TraitId(it.id), | |
353b0b11 | 178 | GenericDef::TraitAlias(it) => GenericDefId::TraitAliasId(it.id), |
064997fb FG |
179 | GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id), |
180 | GenericDef::Impl(it) => GenericDefId::ImplId(it.id), | |
2b03887a | 181 | GenericDef::Variant(it) => GenericDefId::EnumVariantId(it.into()), |
064997fb FG |
182 | GenericDef::Const(it) => GenericDefId::ConstId(it.id), |
183 | } | |
184 | } | |
185 | } | |
186 | ||
187 | impl From<GenericDefId> for GenericDef { | |
188 | fn from(def: GenericDefId) -> Self { | |
189 | match def { | |
190 | GenericDefId::FunctionId(it) => GenericDef::Function(it.into()), | |
191 | GenericDefId::AdtId(it) => GenericDef::Adt(it.into()), | |
192 | GenericDefId::TraitId(it) => GenericDef::Trait(it.into()), | |
353b0b11 | 193 | GenericDefId::TraitAliasId(it) => GenericDef::TraitAlias(it.into()), |
064997fb FG |
194 | GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()), |
195 | GenericDefId::ImplId(it) => GenericDef::Impl(it.into()), | |
2b03887a | 196 | GenericDefId::EnumVariantId(it) => GenericDef::Variant(it.into()), |
064997fb FG |
197 | GenericDefId::ConstId(it) => GenericDef::Const(it.into()), |
198 | } | |
199 | } | |
200 | } | |
201 | ||
202 | impl From<Adt> for GenericDefId { | |
203 | fn from(id: Adt) -> Self { | |
204 | match id { | |
205 | Adt::Struct(it) => it.id.into(), | |
206 | Adt::Union(it) => it.id.into(), | |
207 | Adt::Enum(it) => it.id.into(), | |
208 | } | |
209 | } | |
210 | } | |
211 | ||
212 | impl From<VariantId> for VariantDef { | |
213 | fn from(def: VariantId) -> Self { | |
214 | match def { | |
215 | VariantId::StructId(it) => VariantDef::Struct(it.into()), | |
216 | VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()), | |
217 | VariantId::UnionId(it) => VariantDef::Union(it.into()), | |
218 | } | |
219 | } | |
220 | } | |
221 | ||
222 | impl From<VariantDef> for VariantId { | |
223 | fn from(def: VariantDef) -> Self { | |
224 | match def { | |
225 | VariantDef::Struct(it) => VariantId::StructId(it.id), | |
226 | VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()), | |
227 | VariantDef::Union(it) => VariantId::UnionId(it.id), | |
228 | } | |
229 | } | |
230 | } | |
231 | ||
232 | impl From<Field> for FieldId { | |
233 | fn from(def: Field) -> Self { | |
234 | FieldId { parent: def.parent.into(), local_id: def.id } | |
235 | } | |
236 | } | |
237 | ||
238 | impl From<FieldId> for Field { | |
239 | fn from(def: FieldId) -> Self { | |
240 | Field { parent: def.parent.into(), id: def.local_id } | |
241 | } | |
242 | } | |
243 | ||
244 | impl From<AssocItem> for GenericDefId { | |
245 | fn from(item: AssocItem) -> Self { | |
246 | match item { | |
247 | AssocItem::Function(f) => f.id.into(), | |
248 | AssocItem::Const(c) => c.id.into(), | |
249 | AssocItem::TypeAlias(t) => t.id.into(), | |
250 | } | |
251 | } | |
252 | } | |
253 | ||
353b0b11 FG |
254 | impl From<(DefWithBodyId, BindingId)> for Local { |
255 | fn from((parent, binding_id): (DefWithBodyId, BindingId)) -> Self { | |
256 | Local { parent, binding_id } | |
064997fb FG |
257 | } |
258 | } | |
259 | ||
260 | impl From<(DefWithBodyId, LabelId)> for Label { | |
261 | fn from((parent, label_id): (DefWithBodyId, LabelId)) -> Self { | |
262 | Label { parent, label_id } | |
263 | } | |
264 | } | |
265 | ||
266 | impl From<hir_def::item_scope::ItemInNs> for ItemInNs { | |
267 | fn from(it: hir_def::item_scope::ItemInNs) -> Self { | |
268 | match it { | |
269 | hir_def::item_scope::ItemInNs::Types(it) => ItemInNs::Types(it.into()), | |
270 | hir_def::item_scope::ItemInNs::Values(it) => ItemInNs::Values(it.into()), | |
271 | hir_def::item_scope::ItemInNs::Macros(it) => ItemInNs::Macros(it.into()), | |
272 | } | |
273 | } | |
274 | } | |
275 | ||
276 | impl From<ItemInNs> for hir_def::item_scope::ItemInNs { | |
277 | fn from(it: ItemInNs) -> Self { | |
278 | match it { | |
279 | ItemInNs::Types(it) => Self::Types(it.into()), | |
280 | ItemInNs::Values(it) => Self::Values(it.into()), | |
281 | ItemInNs::Macros(it) => Self::Macros(it.into()), | |
282 | } | |
283 | } | |
284 | } | |
285 | ||
286 | impl From<hir_def::builtin_type::BuiltinType> for BuiltinType { | |
287 | fn from(inner: hir_def::builtin_type::BuiltinType) -> Self { | |
288 | Self { inner } | |
289 | } | |
290 | } | |
291 | ||
292 | impl From<BuiltinType> for hir_def::builtin_type::BuiltinType { | |
293 | fn from(it: BuiltinType) -> Self { | |
294 | it.inner | |
295 | } | |
296 | } |