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 definitelly useful while we
   4 //! are splitting the hir.
   5
   6 use hir_def::{
   7     expr::PatId, item_scope::ItemInNs, AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId,
   8     GenericDefId, ModuleDefId, VariantId,
   9 };
  10
  11 use crate::{
  12     Adt, AssocItem, DefWithBody, Field, GenericDef, Local, MacroDef, ModuleDef, Variant, VariantDef,
  13 };
  14
  15 macro_rules! from_id {
  16     ($(($id:path, $ty:path)),*) => {$(
  17         impl From<$id> for $ty {
  18             fn from(id: $id) -> $ty {
  19                 $ty { id }
  20             }
  21         }
  22         impl From<$ty> for $id {
  23             fn from(ty: $ty) -> $id {
  24                 ty.id
  25             }
  26         }
  27     )*}
  28 }
  29
  30 from_id![
  31     (base_db::CrateId, crate::Crate),
  32     (hir_def::ModuleId, crate::Module),
  33     (hir_def::StructId, crate::Struct),
  34     (hir_def::UnionId, crate::Union),
  35     (hir_def::EnumId, crate::Enum),
  36     (hir_def::TypeAliasId, crate::TypeAlias),
  37     (hir_def::TraitId, crate::Trait),
  38     (hir_def::StaticId, crate::Static),
  39     (hir_def::ConstId, crate::Const),
  40     (hir_def::FunctionId, crate::Function),
  41     (hir_def::ImplId, crate::Impl),
  42     (hir_def::TypeParamId, crate::TypeParam),
  43     (hir_def::LifetimeParamId, crate::LifetimeParam),
  44     (hir_expand::MacroDefId, crate::MacroDef)
  45 ];
  46
  47 impl From<AdtId> for Adt {
  48     fn from(id: AdtId) -> Self {
  49         match id {
  50             AdtId::StructId(it) => Adt::Struct(it.into()),
  51             AdtId::UnionId(it) => Adt::Union(it.into()),
  52             AdtId::EnumId(it) => Adt::Enum(it.into()),
  53         }
  54     }
  55 }
  56
  57 impl From<Adt> for AdtId {
  58     fn from(id: Adt) -> Self {
  59         match id {
  60             Adt::Struct(it) => AdtId::StructId(it.id),
  61             Adt::Union(it) => AdtId::UnionId(it.id),
  62             Adt::Enum(it) => AdtId::EnumId(it.id),
  63         }
  64     }
  65 }
  66
  67 impl From<EnumVariantId> for Variant {
  68     fn from(id: EnumVariantId) -> Self {
  69         Variant { parent: id.parent.into(), id: id.local_id }
  70     }
  71 }
  72
  73 impl From<Variant> for EnumVariantId {
  74     fn from(def: Variant) -> Self {
  75         EnumVariantId { parent: def.parent.id, local_id: def.id }
  76     }
  77 }
  78
  79 impl From<ModuleDefId> for ModuleDef {
  80     fn from(id: ModuleDefId) -> Self {
  81         match id {
  82             ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
  83             ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
  84             ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
  85             ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
  86             ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
  87             ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
  88             ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
  89             ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
  90             ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it),
  91         }
  92     }
  93 }
  94
  95 impl From<ModuleDef> for ModuleDefId {
  96     fn from(id: ModuleDef) -> Self {
  97         match id {
  98             ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
  99             ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
 100             ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
 101             ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
 102             ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
 103             ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
 104             ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
 105             ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
 106             ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it),
 107         }
 108     }
 109 }
 110
 111 impl From<DefWithBody> for DefWithBodyId {
 112     fn from(def: DefWithBody) -> Self {
 113         match def {
 114             DefWithBody::Function(it) => DefWithBodyId::FunctionId(it.id),
 115             DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),
 116             DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),
 117         }
 118     }
 119 }
 120
 121 impl From<DefWithBodyId> for DefWithBody {
 122     fn from(def: DefWithBodyId) -> Self {
 123         match def {
 124             DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
 125             DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
 126             DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
 127         }
 128     }
 129 }
 130
 131 impl From<AssocItemId> for AssocItem {
 132     fn from(def: AssocItemId) -> Self {
 133         match def {
 134             AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
 135             AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
 136             AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
 137         }
 138     }
 139 }
 140
 141 impl From<GenericDef> for GenericDefId {
 142     fn from(def: GenericDef) -> Self {
 143         match def {
 144             GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
 145             GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
 146             GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
 147             GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
 148             GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
 149             GenericDef::Variant(it) => {
 150                 GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
 151             }
 152             GenericDef::Const(it) => GenericDefId::ConstId(it.id),
 153         }
 154     }
 155 }
 156
 157 impl From<GenericDefId> for GenericDef {
 158     fn from(def: GenericDefId) -> Self {
 159         match def {
 160             GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
 161             GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
 162             GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
 163             GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
 164             GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
 165             GenericDefId::EnumVariantId(it) => {
 166                 GenericDef::Variant(Variant { parent: it.parent.into(), id: it.local_id })
 167             }
 168             GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
 169         }
 170     }
 171 }
 172
 173 impl From<Adt> for GenericDefId {
 174     fn from(id: Adt) -> Self {
 175         match id {
 176             Adt::Struct(it) => it.id.into(),
 177             Adt::Union(it) => it.id.into(),
 178             Adt::Enum(it) => it.id.into(),
 179         }
 180     }
 181 }
 182
 183 impl From<VariantId> for VariantDef {
 184     fn from(def: VariantId) -> Self {
 185         match def {
 186             VariantId::StructId(it) => VariantDef::Struct(it.into()),
 187             VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()),
 188             VariantId::UnionId(it) => VariantDef::Union(it.into()),
 189         }
 190     }
 191 }
 192
 193 impl From<VariantDef> for VariantId {
 194     fn from(def: VariantDef) -> Self {
 195         match def {
 196             VariantDef::Struct(it) => VariantId::StructId(it.id),
 197             VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()),
 198             VariantDef::Union(it) => VariantId::UnionId(it.id),
 199         }
 200     }
 201 }
 202
 203 impl From<Field> for FieldId {
 204     fn from(def: Field) -> Self {
 205         FieldId { parent: def.parent.into(), local_id: def.id }
 206     }
 207 }
 208
 209 impl From<FieldId> for Field {
 210     fn from(def: FieldId) -> Self {
 211         Field { parent: def.parent.into(), id: def.local_id }
 212     }
 213 }
 214
 215 impl From<AssocItem> for GenericDefId {
 216     fn from(item: AssocItem) -> Self {
 217         match item {
 218             AssocItem::Function(f) => f.id.into(),
 219             AssocItem::Const(c) => c.id.into(),
 220             AssocItem::TypeAlias(t) => t.id.into(),
 221         }
 222     }
 223 }
 224
 225 impl From<(DefWithBodyId, PatId)> for Local {
 226     fn from((parent, pat_id): (DefWithBodyId, PatId)) -> Self {
 227         Local { parent, pat_id }
 228     }
 229 }
 230
 231 impl From<MacroDef> for ItemInNs {
 232     fn from(macro_def: MacroDef) -> Self {
 233         ItemInNs::Macros(macro_def.into())
 234     }
 235 }
 236
 237 impl From<ModuleDef> for ItemInNs {
 238     fn from(module_def: ModuleDef) -> Self {
 239         match module_def {
 240             ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
 241                 ItemInNs::Values(module_def.into())
 242             }
 243             _ => ItemInNs::Types(module_def.into()),
 244         }
 245     }
 246 }