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