crates/hir/src/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
   6 use hir_def::{
   7     expr::{LabelId, PatId},
   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),
  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 ];
  50
  51 impl From<AdtId> for Adt {
  52     fn from(id: AdtId) -> Self {
  53         match id {
  54             AdtId::StructId(it) => Adt::Struct(it.into()),
  55             AdtId::UnionId(it) => Adt::Union(it.into()),
  56             AdtId::EnumId(it) => Adt::Enum(it.into()),
  57         }
  58     }
  59 }
  60
  61 impl From<Adt> for AdtId {
  62     fn from(id: Adt) -> Self {
  63         match id {
  64             Adt::Struct(it) => AdtId::StructId(it.id),
  65             Adt::Union(it) => AdtId::UnionId(it.id),
  66             Adt::Enum(it) => AdtId::EnumId(it.id),
  67         }
  68     }
  69 }
  70
  71 impl From<GenericParamId> for GenericParam {
  72     fn from(id: GenericParamId) -> Self {
  73         match id {
  74             GenericParamId::TypeParamId(it) => GenericParam::TypeParam(it.into()),
  75             GenericParamId::ConstParamId(it) => GenericParam::ConstParam(it.into()),
  76             GenericParamId::LifetimeParamId(it) => GenericParam::LifetimeParam(it.into()),
  77         }
  78     }
  79 }
  80
  81 impl From<GenericParam> for GenericParamId {
  82     fn from(id: GenericParam) -> Self {
  83         match id {
  84             GenericParam::LifetimeParam(it) => GenericParamId::LifetimeParamId(it.id),
  85             GenericParam::ConstParam(it) => GenericParamId::ConstParamId(it.id),
  86             GenericParam::TypeParam(it) => GenericParamId::TypeParamId(it.id),
  87         }
  88     }
  89 }
  90
  91 impl From<EnumVariantId> for Variant {
  92     fn from(id: EnumVariantId) -> Self {
  93         Variant { parent: id.parent.into(), id: id.local_id }
  94     }
  95 }
  96
  97 impl From<Variant> for EnumVariantId {
  98     fn from(def: Variant) -> Self {
  99         EnumVariantId { parent: def.parent.id, local_id: def.id }
 100     }
 101 }
 102
 103 impl From<ModuleDefId> for ModuleDef {
 104     fn from(id: ModuleDefId) -> Self {
 105         match id {
 106             ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
 107             ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
 108             ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
 109             ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
 110             ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
 111             ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
 112             ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
 113             ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
 114             ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it.into()),
 115             ModuleDefId::MacroId(it) => ModuleDef::Macro(it.into()),
 116         }
 117     }
 118 }
 119
 120 impl From<ModuleDef> for ModuleDefId {
 121     fn from(id: ModuleDef) -> Self {
 122         match id {
 123             ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
 124             ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
 125             ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
 126             ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
 127             ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
 128             ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
 129             ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
 130             ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
 131             ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()),
 132             ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()),
 133         }
 134     }
 135 }
 136
 137 impl From<DefWithBody> for DefWithBodyId {
 138     fn from(def: DefWithBody) -> Self {
 139         match def {
 140             DefWithBody::Function(it) => DefWithBodyId::FunctionId(it.id),
 141             DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),
 142             DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),
 143         }
 144     }
 145 }
 146
 147 impl From<DefWithBodyId> for DefWithBody {
 148     fn from(def: DefWithBodyId) -> Self {
 149         match def {
 150             DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
 151             DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
 152             DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
 153         }
 154     }
 155 }
 156
 157 impl From<AssocItemId> for AssocItem {
 158     fn from(def: AssocItemId) -> Self {
 159         match def {
 160             AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
 161             AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
 162             AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
 163         }
 164     }
 165 }
 166
 167 impl From<GenericDef> for GenericDefId {
 168     fn from(def: GenericDef) -> Self {
 169         match def {
 170             GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
 171             GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
 172             GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
 173             GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
 174             GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
 175             GenericDef::Variant(it) => {
 176                 GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
 177             }
 178             GenericDef::Const(it) => GenericDefId::ConstId(it.id),
 179         }
 180     }
 181 }
 182
 183 impl From<GenericDefId> for GenericDef {
 184     fn from(def: GenericDefId) -> Self {
 185         match def {
 186             GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
 187             GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
 188             GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
 189             GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
 190             GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
 191             GenericDefId::EnumVariantId(it) => {
 192                 GenericDef::Variant(Variant { parent: it.parent.into(), id: it.local_id })
 193             }
 194             GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
 195         }
 196     }
 197 }
 198
 199 impl 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
 209 impl 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
 219 impl 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
 229 impl From<Field> for FieldId {
 230     fn from(def: Field) -> Self {
 231         FieldId { parent: def.parent.into(), local_id: def.id }
 232     }
 233 }
 234
 235 impl From<FieldId> for Field {
 236     fn from(def: FieldId) -> Self {
 237         Field { parent: def.parent.into(), id: def.local_id }
 238     }
 239 }
 240
 241 impl 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
 251 impl From<(DefWithBodyId, PatId)> for Local {
 252     fn from((parent, pat_id): (DefWithBodyId, PatId)) -> Self {
 253         Local { parent, pat_id }
 254     }
 255 }
 256
 257 impl From<(DefWithBodyId, LabelId)> for Label {
 258     fn from((parent, label_id): (DefWithBodyId, LabelId)) -> Self {
 259         Label { parent, label_id }
 260     }
 261 }
 262
 263 impl 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
 273 impl 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
 283 impl From<hir_def::builtin_type::BuiltinType> for BuiltinType {
 284     fn from(inner: hir_def::builtin_type::BuiltinType) -> Self {
 285         Self { inner }
 286     }
 287 }
 288
 289 impl From<BuiltinType> for hir_def::builtin_type::BuiltinType {
 290     fn from(it: BuiltinType) -> Self {
 291         it.inner
 292     }
 293 }