use std::iter;
use either::Either;
-use hir::{AsName, EnumVariant, Module, ModuleDef, Name};
+use hir::{AsName, Module, ModuleDef, Name, Variant};
use ide_db::helpers::{
insert_use::{insert_use, ImportScope},
mod_path_to_ast,
let variant_hir_name = variant_hir.name(ctx.db());
let enum_module_def = ModuleDef::from(enum_hir);
let usages =
- Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir)).usages(&ctx.sema).all();
+ Definition::ModuleDef(ModuleDef::Variant(variant_hir)).usages(&ctx.sema).all();
let mut visited_modules_set = FxHashSet::default();
let current_module = enum_hir.module(ctx.db());
}
}
-fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &EnumVariant) -> bool {
+fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Variant) -> bool {
variant
.parent_enum(db)
.module(db)
// only check type-namespace
hir::ScopeDef::ModuleDef(def) => matches!(def,
ModuleDef::Module(_) | ModuleDef::Adt(_) |
- ModuleDef::EnumVariant(_) | ModuleDef::Trait(_) |
+ ModuleDef::Variant(_) | ModuleDef::Trait(_) |
ModuleDef::TypeAlias(_) | ModuleDef::BuiltinType(_)
),
_ => false,
.collect()
}
-fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
+fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::Variant) -> Option<ast::Pat> {
let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
// FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
(vis_offset(syntax), in_file_source.value.visibility(), syntax.text_range(), file_id)
}
// Enum variants can't be private, we can't modify builtin types
- hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
+ hir::ModuleDef::Variant(_) | hir::ModuleDef::BuiltinType(_) => return None,
};
Some((offset, current_visibility, target, target_file, target_name))
use crate::{
item::Builder,
render::{
- const_::render_const, enum_variant::render_enum_variant, function::render_fn,
+ const_::render_const, enum_variant::render_variant, function::render_fn,
macro_::render_macro, render_field, render_resolution, render_tuple_field,
type_alias::render_type_alias, RenderContext,
},
pub(crate) fn add_qualified_enum_variant(
&mut self,
ctx: &CompletionContext,
- variant: hir::EnumVariant,
+ variant: hir::Variant,
path: ModPath,
) {
- let item = render_enum_variant(RenderContext::new(ctx), None, None, variant, Some(path));
+ let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
self.add(item);
}
pub(crate) fn add_enum_variant(
&mut self,
ctx: &CompletionContext,
- variant: hir::EnumVariant,
+ variant: hir::Variant,
local_name: Option<String>,
) {
- let item = render_enum_variant(RenderContext::new(ctx), None, local_name, variant, None);
+ let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
self.add(item);
}
}
def,
hir::ModuleDef::Adt(hir::Adt::Enum(..))
| hir::ModuleDef::Adt(hir::Adt::Struct(..))
- | hir::ModuleDef::EnumVariant(..)
+ | hir::ModuleDef::Variant(..)
| hir::ModuleDef::Const(..)
| hir::ModuleDef::Module(..)
)
CompletionKind, CompletionScore,
};
-use crate::render::{enum_variant::render_enum_variant, function::render_fn, macro_::render_macro};
+use crate::render::{enum_variant::render_variant, function::render_fn, macro_::render_macro};
pub(crate) fn render_field<'a>(
ctx: RenderContext<'a>,
let item = render_fn(self.ctx, import_to_add, Some(local_name), *func);
return Some(item);
}
- ScopeDef::ModuleDef(EnumVariant(var)) => {
- let item =
- render_enum_variant(self.ctx, import_to_add, Some(local_name), *var, None);
+ ScopeDef::ModuleDef(Variant(var)) => {
+ let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
return Some(item);
}
ScopeDef::MacroDef(mac) => {
match resolution {
ScopeDef::ModuleDef(Module(it)) => it.docs(self.ctx.db()),
ScopeDef::ModuleDef(Adt(it)) => it.docs(self.ctx.db()),
- ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(self.ctx.db()),
+ ScopeDef::ModuleDef(Variant(it)) => it.docs(self.ctx.db()),
ScopeDef::ModuleDef(Const(it)) => it.docs(self.ctx.db()),
ScopeDef::ModuleDef(Static(it)) => it.docs(self.ctx.db()),
ScopeDef::ModuleDef(Trait(it)) => it.docs(self.ctx.db()),
render::{builder_ext::Params, RenderContext},
};
-pub(crate) fn render_enum_variant<'a>(
+pub(crate) fn render_variant<'a>(
ctx: RenderContext<'a>,
import_to_add: Option<ImportEdit>,
local_name: Option<String>,
- variant: hir::EnumVariant,
+ variant: hir::Variant,
path: Option<ModPath>,
) -> CompletionItem {
let _p = profile::span("render_enum_variant");
- EnumVariantRender::new(ctx, local_name, variant, path).render(import_to_add)
+ EnumRender::new(ctx, local_name, variant, path).render(import_to_add)
}
#[derive(Debug)]
-struct EnumVariantRender<'a> {
+struct EnumRender<'a> {
ctx: RenderContext<'a>,
name: String,
- variant: hir::EnumVariant,
+ variant: hir::Variant,
path: Option<ModPath>,
qualified_name: String,
short_qualified_name: String,
variant_kind: StructKind,
}
-impl<'a> EnumVariantRender<'a> {
+impl<'a> EnumRender<'a> {
fn new(
ctx: RenderContext<'a>,
local_name: Option<String>,
- variant: hir::EnumVariant,
+ variant: hir::Variant,
path: Option<ModPath>,
- ) -> EnumVariantRender<'a> {
+ ) -> EnumRender<'a> {
let name = local_name.unwrap_or_else(|| variant.name(ctx.db()).to_string());
let variant_kind = variant.kind(ctx.db());
None => (name.to_string(), name.to_string()),
};
- EnumVariantRender {
- ctx,
- name,
- variant,
- path,
- qualified_name,
- short_qualified_name,
- variant_kind,
- }
+ EnumRender { ctx, name, variant, path, qualified_name, short_qualified_name, variant_kind }
}
fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
use syntax::ast;
use crate::{
- Adt, Const, Enum, EnumVariant, Field, Function, MacroDef, Module, ModuleDef, Static, Struct,
- Trait, TypeAlias, Union,
+ Adt, Const, Enum, Field, Function, MacroDef, Module, ModuleDef, Static, Struct, Trait,
+ TypeAlias, Union, Variant,
};
pub trait HasAttrs {
impl_has_attrs![
(Field, FieldId),
- (EnumVariant, EnumVariantId),
+ (Variant, EnumVariantId),
(Static, StaticId),
(Const, ConstId),
(Trait, TraitId),
Function(Function),
Adt(Adt),
// Can't be directly declared, but can be imported.
- EnumVariant(EnumVariant),
+ Variant(Variant),
Const(Const),
Static(Static),
Trait(Trait),
Module,
Function,
Adt(Struct, Enum, Union),
- EnumVariant,
+ Variant,
Const,
Static,
Trait,
match var {
VariantDef::Struct(t) => Adt::from(t).into(),
VariantDef::Union(t) => Adt::from(t).into(),
- VariantDef::EnumVariant(t) => t.into(),
+ VariantDef::Variant(t) => t.into(),
}
}
}
ModuleDef::Module(it) => it.parent(db),
ModuleDef::Function(it) => Some(it.module(db)),
ModuleDef::Adt(it) => Some(it.module(db)),
- ModuleDef::EnumVariant(it) => Some(it.module(db)),
+ ModuleDef::Variant(it) => Some(it.module(db)),
ModuleDef::Const(it) => Some(it.module(db)),
ModuleDef::Static(it) => Some(it.module(db)),
ModuleDef::Trait(it) => Some(it.module(db)),
ModuleDef::Module(it) => it.parent(db)?,
ModuleDef::Function(it) => return Some(it.visibility(db)),
ModuleDef::Adt(it) => it.module(db),
- ModuleDef::EnumVariant(it) => {
+ ModuleDef::Variant(it) => {
let parent = it.parent_enum(db);
let module = it.module(db);
return module.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)));
ModuleDef::Adt(it) => Some(it.name(db)),
ModuleDef::Trait(it) => Some(it.name(db)),
ModuleDef::Function(it) => Some(it.name(db)),
- ModuleDef::EnumVariant(it) => Some(it.name(db)),
+ ModuleDef::Variant(it) => Some(it.name(db)),
ModuleDef::TypeAlias(it) => Some(it.name(db)),
ModuleDef::Module(it) => it.name(db),
ModuleDef::Const(it) => it.name(db),
let generic_def_id: GenericDefId = match self.parent {
VariantDef::Struct(it) => it.id.into(),
VariantDef::Union(it) => it.id.into(),
- VariantDef::EnumVariant(it) => it.parent.id.into(),
+ VariantDef::Variant(it) => it.parent.id.into(),
};
let substs = Substs::type_params(db, generic_def_id);
let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
db.enum_data(self.id).name.clone()
}
- pub fn variants(self, db: &dyn HirDatabase) -> Vec<EnumVariant> {
- db.enum_data(self.id)
- .variants
- .iter()
- .map(|(id, _)| EnumVariant { parent: self, id })
- .collect()
+ pub fn variants(self, db: &dyn HirDatabase) -> Vec<Variant> {
+ db.enum_data(self.id).variants.iter().map(|(id, _)| Variant { parent: self, id }).collect()
}
pub fn ty(self, db: &dyn HirDatabase) -> Type {
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct EnumVariant {
+pub struct Variant {
pub(crate) parent: Enum,
pub(crate) id: LocalEnumVariantId,
}
-impl EnumVariant {
+impl Variant {
pub fn module(self, db: &dyn HirDatabase) -> Module {
self.parent.module(db)
}
pub enum VariantDef {
Struct(Struct),
Union(Union),
- EnumVariant(EnumVariant),
+ Variant(Variant),
}
-impl_from!(Struct, Union, EnumVariant for VariantDef);
+impl_from!(Struct, Union, Variant for VariantDef);
impl VariantDef {
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
match self {
VariantDef::Struct(it) => it.fields(db),
VariantDef::Union(it) => it.fields(db),
- VariantDef::EnumVariant(it) => it.fields(db),
+ VariantDef::Variant(it) => it.fields(db),
}
}
match self {
VariantDef::Struct(it) => it.module(db),
VariantDef::Union(it) => it.module(db),
- VariantDef::EnumVariant(it) => it.module(db),
+ VariantDef::Variant(it) => it.module(db),
}
}
match self {
VariantDef::Struct(s) => s.name(db),
VariantDef::Union(u) => u.name(db),
- VariantDef::EnumVariant(e) => e.name(db),
+ VariantDef::Variant(e) => e.name(db),
}
}
match self {
VariantDef::Struct(it) => it.variant_data(db),
VariantDef::Union(it) => it.variant_data(db),
- VariantDef::EnumVariant(it) => it.variant_data(db),
+ VariantDef::Variant(it) => it.variant_data(db),
}
}
}
Impl(Impl),
// enum variants cannot have generics themselves, but their parent enums
// can, and this makes some code easier to write
- EnumVariant(EnumVariant),
+ Variant(Variant),
// consts can have type parameters from their parents (i.e. associated consts of traits)
Const(Const),
}
Trait,
TypeAlias,
Impl,
- EnumVariant,
+ Variant,
Const
for GenericDef
);
pub enum CallableKind {
Function(Function),
TupleStruct(Struct),
- TupleEnumVariant(EnumVariant),
+ TupleEnumVariant(Variant),
Closure,
}
};
use crate::{
- Adt, AssocItem, DefWithBody, EnumVariant, Field, GenericDef, Local, MacroDef, ModuleDef,
- VariantDef,
+ Adt, AssocItem, DefWithBody, Field, GenericDef, Local, MacroDef, ModuleDef, Variant, VariantDef,
};
macro_rules! from_id {
}
}
-impl From<EnumVariantId> for EnumVariant {
+impl From<EnumVariantId> for Variant {
fn from(id: EnumVariantId) -> Self {
- EnumVariant { parent: id.parent.into(), id: id.local_id }
+ Variant { parent: id.parent.into(), id: id.local_id }
}
}
-impl From<EnumVariant> for EnumVariantId {
- fn from(def: EnumVariant) -> Self {
+impl From<Variant> for EnumVariantId {
+ fn from(def: Variant) -> Self {
EnumVariantId { parent: def.parent.id, local_id: def.id }
}
}
ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
- ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
+ ModuleDefId::EnumVariantId(it) => ModuleDef::Variant(it.into()),
ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
- ModuleDef::EnumVariant(it) => ModuleDefId::EnumVariantId(it.into()),
+ ModuleDef::Variant(it) => ModuleDefId::EnumVariantId(it.into()),
ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
- GenericDef::EnumVariant(it) => {
+ GenericDef::Variant(it) => {
GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
}
GenericDef::Const(it) => GenericDefId::ConstId(it.id),
GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
GenericDefId::EnumVariantId(it) => {
- GenericDef::EnumVariant(EnumVariant { parent: it.parent.into(), id: it.local_id })
+ GenericDef::Variant(Variant { parent: it.parent.into(), id: it.local_id })
}
GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
}
fn from(def: VariantId) -> Self {
match def {
VariantId::StructId(it) => VariantDef::Struct(it.into()),
- VariantId::EnumVariantId(it) => VariantDef::EnumVariant(it.into()),
+ VariantId::EnumVariantId(it) => VariantDef::Variant(it.into()),
VariantId::UnionId(it) => VariantDef::Union(it.into()),
}
}
fn from(def: VariantDef) -> Self {
match def {
VariantDef::Struct(it) => VariantId::StructId(it.id),
- VariantDef::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
+ VariantDef::Variant(it) => VariantId::EnumVariantId(it.into()),
VariantDef::Union(it) => VariantId::UnionId(it.id),
}
}
use syntax::ast;
use crate::{
- db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, Impl, LifetimeParam,
- MacroDef, Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
+ db::HirDatabase, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam, MacroDef,
+ Module, Static, Struct, Trait, TypeAlias, TypeParam, Union, Variant,
};
pub trait HasSource {
self.id.lookup(db.upcast()).source(db.upcast())
}
}
-impl HasSource for EnumVariant {
+impl HasSource for Variant {
type Ast = ast::Variant;
fn source(self, db: &dyn HirDatabase) -> InFile<ast::Variant> {
self.parent.id.child_source(db.upcast()).map(|map| map[self.id].clone())
attrs::{HasAttrs, Namespace},
code_model::{
Access, Adt, AsAssocItem, AssocItem, AssocItemContainer, Callable, CallableKind, Const,
- Crate, CrateDependency, DefWithBody, Enum, EnumVariant, Field, FieldSource, Function,
- GenericDef, HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module, ModuleDef,
- ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
+ Crate, CrateDependency, DefWithBody, Enum, Field, FieldSource, Function, GenericDef,
+ HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module, ModuleDef, ScopeDef, Static,
+ Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
},
has_source::HasSource,
semantics::{PathResolution, Semantics, SemanticsScope},
Some(TypeNs::BuiltinType(*builtin))
}
PathResolution::Def(ModuleDef::Const(_))
- | PathResolution::Def(ModuleDef::EnumVariant(_))
+ | PathResolution::Def(ModuleDef::Variant(_))
| PathResolution::Def(ModuleDef::Function(_))
| PathResolution::Def(ModuleDef::Module(_))
| PathResolution::Def(ModuleDef::Static(_))
(crate::Function, ast::Fn, fn_to_def),
(crate::Field, ast::RecordField, record_field_to_def),
(crate::Field, ast::TupleField, tuple_field_to_def),
- (crate::EnumVariant, ast::Variant, enum_variant_to_def),
+ (crate::Variant, ast::Variant, enum_variant_to_def),
(crate::TypeParam, ast::TypeParam, type_param_to_def),
(crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
(crate::MacroDef, ast::MacroRules, macro_rules_to_def),
};
use crate::{
- db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Field, Function, Local,
- MacroDef, ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
+ db::HirDatabase, semantics::PathResolution, Adt, Const, Field, Function, Local, MacroDef,
+ ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Variant,
};
use base_db::CrateId;
if let Some(VariantId::EnumVariantId(variant)) =
self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
{
- return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+ return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
}
}
if let Some(VariantId::EnumVariantId(variant)) =
self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
{
- return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+ return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
}
}
if let Some(VariantId::EnumVariantId(variant)) =
self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
{
- return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+ return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
}
}
if let Some(VariantId::EnumVariantId(variant)) =
self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
{
- return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
+ return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
}
}
TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
PathResolution::Def(Adt::from(it).into())
}
- TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+ TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
- ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+ ValueNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
ValueNs::ImplSelf(impl_id) => PathResolution::SelfType(impl_id.into()),
};
Some(res)
TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => PathResolution::Def(Adt::from(it).into()),
- TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+ TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
def_file_id = source.file_id;
source.value.record_field_list()?
}
- VariantDef::EnumVariant(e) => {
+ VariantDef::Variant(e) => {
module = e.module(sema.db);
let source = e.source(sema.db);
def_file_id = source.file_id;
hir::ModuleDef::Module(it) => it.to_nav(db),
hir::ModuleDef::Function(it) => it.to_nav(db),
hir::ModuleDef::Adt(it) => it.to_nav(db),
- hir::ModuleDef::EnumVariant(it) => it.to_nav(db),
+ hir::ModuleDef::Variant(it) => it.to_nav(db),
hir::ModuleDef::Const(it) => it.to_nav(db),
hir::ModuleDef::Static(it) => it.to_nav(db),
hir::ModuleDef::Trait(it) => it.to_nav(db),
impl ToNavFromAst for hir::Enum {
const KIND: SymbolKind = SymbolKind::Enum;
}
-impl ToNavFromAst for hir::EnumVariant {
+impl ToNavFromAst for hir::Variant {
const KIND: SymbolKind = SymbolKind::Variant;
}
impl ToNavFromAst for hir::Union {
ModuleDef::Module(it) => it.resolve_doc_path(db, link, ns),
ModuleDef::Function(it) => it.resolve_doc_path(db, link, ns),
ModuleDef::Adt(it) => it.resolve_doc_path(db, link, ns),
- ModuleDef::EnumVariant(it) => it.resolve_doc_path(db, link, ns),
+ ModuleDef::Variant(it) => it.resolve_doc_path(db, link, ns),
ModuleDef::Const(it) => it.resolve_doc_path(db, link, ns),
ModuleDef::Static(it) => it.resolve_doc_path(db, link, ns),
ModuleDef::Trait(it) => it.resolve_doc_path(db, link, ns),
ModuleDef::TypeAlias(t) => format!("type.{}.html", t.name(db)),
ModuleDef::BuiltinType(t) => format!("primitive.{}.html", t.as_name()),
ModuleDef::Function(f) => format!("fn.{}.html", f.name(db)),
- ModuleDef::EnumVariant(ev) => {
+ ModuleDef::Variant(ev) => {
format!("enum.{}.html#variant.{}", ev.parent_enum(db).name(db), ev.name(db))
}
ModuleDef::Const(c) => format!("const.{}.html", c.name(db)?),
AssocItemContainer::Trait(t) => Some(t.name(db)),
AssocItemContainer::Impl(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)),
},
- ModuleDef::EnumVariant(e) => Some(e.parent_enum(db).name(db)),
+ ModuleDef::Variant(e) => Some(e.parent_enum(db).name(db)),
_ => None,
},
_ => None,
ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it, mod_path),
ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it, mod_path),
ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it, mod_path),
- ModuleDef::EnumVariant(it) => from_def_source(db, it, mod_path),
+ ModuleDef::Variant(it) => from_def_source(db, it, mod_path),
ModuleDef::Const(it) => from_def_source(db, it, mod_path),
ModuleDef::Static(it) => from_def_source(db, it, mod_path),
ModuleDef::Trait(it) => from_def_source(db, it, mod_path),
hir::ModuleDef::Module(it) => it.attrs(sema.db),
hir::ModuleDef::Function(it) => it.attrs(sema.db),
hir::ModuleDef::Adt(it) => it.attrs(sema.db),
- hir::ModuleDef::EnumVariant(it) => it.attrs(sema.db),
+ hir::ModuleDef::Variant(it) => it.attrs(sema.db),
hir::ModuleDef::Const(it) => it.attrs(sema.db),
hir::ModuleDef::Static(it) => it.attrs(sema.db),
hir::ModuleDef::Trait(it) => it.attrs(sema.db),
hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Symbol(SymbolKind::Struct),
hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Symbol(SymbolKind::Enum),
hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Symbol(SymbolKind::Union),
- hir::ModuleDef::EnumVariant(_) => HighlightTag::Symbol(SymbolKind::Variant),
+ hir::ModuleDef::Variant(_) => HighlightTag::Symbol(SymbolKind::Variant),
hir::ModuleDef::Const(konst) => {
let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Const));
if konst.as_assoc_item(db).is_some() {
hir::Adt::Union(it) => it.name(db),
hir::Adt::Enum(it) => it.name(db),
},
- hir::ModuleDef::EnumVariant(it) => it.name(db),
+ hir::ModuleDef::Variant(it) => it.name(db),
hir::ModuleDef::Const(it) => it.name(db)?,
hir::ModuleDef::Static(it) => it.name(db)?,
hir::ModuleDef::Trait(it) => it.name(db),
Some(NameClass::Definition(Definition::ModuleDef(def.into())))
},
ast::Variant(it) => {
- let def: hir::EnumVariant = sema.to_def(&it)?;
+ let def: hir::Variant = sema.to_def(&it)?;
Some(NameClass::Definition(Definition::ModuleDef(def.into())))
},
ast::Fn(it) => {
hir::GenericDef::Trait(it) => it.source(db).value.syntax().text_range(),
hir::GenericDef::TypeAlias(it) => it.source(db).value.syntax().text_range(),
hir::GenericDef::Impl(it) => it.source(db).value.syntax().text_range(),
- hir::GenericDef::EnumVariant(it) => it.source(db).value.syntax().text_range(),
+ hir::GenericDef::Variant(it) => it.source(db).value.syntax().text_range(),
hir::GenericDef::Const(it) => it.source(db).value.syntax().text_range(),
};
let mut res = FxHashMap::default();