Align code_model name with ungrammar

crates/completion/src/completions.rs

@@ -19,7 +19,7 @@ use hir::{ModPath, ScopeDef, Type};
 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,
     },
@@ -120,20 +120,20 @@ impl Completions {
     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);
     }
 }

crates/completion/src/completions/pattern.rs

@@ -23,7 +23,7 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                         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(..)
                     )

crates/completion/src/render.rs

@@ -19,7 +19,7 @@ use crate::{
     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>,
@@ -159,9 +159,8 @@ impl<'a> Render<'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) => {
@@ -257,7 +256,7 @@ impl<'a> Render<'a> {
         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()),

crates/completion/src/render/enum_variant.rs

@@ -9,35 +9,35 @@ use crate::{
     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());
 
@@ -51,15 +51,7 @@ impl<'a> EnumVariantRender<'a> {
             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 {