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