Get rid of do-er antipattern

crates/completion/src/render/const_.rs

@@ -11,20 +11,27 @@ use crate::{
     render::RenderContext,
 };
 
+pub(crate) fn render_const<'a>(
+    ctx: RenderContext<'a>,
+    const_: hir::Const,
+) -> Option<CompletionItem> {
+    ConstRender::new(ctx, const_).render()
+}
+
 #[derive(Debug)]
-pub(crate) struct ConstRender<'a> {
+struct ConstRender<'a> {
     ctx: RenderContext<'a>,
     const_: hir::Const,
     ast_node: Const,
 }
 
 impl<'a> ConstRender<'a> {
-    pub(crate) fn new(ctx: RenderContext<'a>, const_: hir::Const) -> ConstRender<'a> {
+    fn new(ctx: RenderContext<'a>, const_: hir::Const) -> ConstRender<'a> {
         let ast_node = const_.source(ctx.db()).value;
         ConstRender { ctx, const_, ast_node }
     }
 
-    pub(crate) fn render(self) -> Option<CompletionItem> {
+    fn render(self) -> Option<CompletionItem> {
         let name = self.name()?;
         let detail = self.detail();
 

crates/completion/src/render/enum_variant.rs

@@ -9,8 +9,17 @@ use crate::{
     render::{builder_ext::Params, RenderContext},
 };
 
+pub(crate) fn render_enum_variant<'a>(
+    ctx: RenderContext<'a>,
+    local_name: Option<String>,
+    variant: hir::EnumVariant,
+    path: Option<ModPath>,
+) -> CompletionItem {
+    EnumVariantRender::new(ctx, local_name, variant, path).render()
+}
+
 #[derive(Debug)]
-pub(crate) struct EnumVariantRender<'a> {
+struct EnumVariantRender<'a> {
     ctx: RenderContext<'a>,
     name: String,
     variant: hir::EnumVariant,
@@ -21,7 +30,7 @@ pub(crate) struct EnumVariantRender<'a> {
 }
 
 impl<'a> EnumVariantRender<'a> {
-    pub(crate) fn new(
+    fn new(
         ctx: RenderContext<'a>,
         local_name: Option<String>,
         variant: hir::EnumVariant,
@@ -51,7 +60,7 @@ impl<'a> EnumVariantRender<'a> {
         }
     }
 
-    pub(crate) fn render(self) -> CompletionItem {
+    fn render(self) -> CompletionItem {
         let mut builder = CompletionItem::new(
             CompletionKind::Reference,
             self.ctx.source_range(),

crates/completion/src/render/function.rs

@@ -8,8 +8,16 @@ use crate::{
     render::{builder_ext::Params, RenderContext},
 };
 
+pub(crate) fn render_fn<'a>(
+    ctx: RenderContext<'a>,
+    local_name: Option<String>,
+    fn_: hir::Function,
+) -> CompletionItem {
+    FunctionRender::new(ctx, local_name, fn_).render()
+}
+
 #[derive(Debug)]
-pub(crate) struct FunctionRender<'a> {
+struct FunctionRender<'a> {
     ctx: RenderContext<'a>,
     name: String,
     fn_: hir::Function,
@@ -17,7 +25,7 @@ pub(crate) struct FunctionRender<'a> {
 }
 
 impl<'a> FunctionRender<'a> {
-    pub(crate) fn new(
+    fn new(
         ctx: RenderContext<'a>,
         local_name: Option<String>,
         fn_: hir::Function,
@@ -28,7 +36,7 @@ impl<'a> FunctionRender<'a> {
         FunctionRender { ctx, name, fn_, ast_node }
     }
 
-    pub(crate) fn render(self) -> CompletionItem {
+    fn render(self) -> CompletionItem {
         let params = self.params();
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
             .kind(self.kind())

crates/completion/src/render/macro_.rs

@@ -9,8 +9,16 @@ use crate::{
     render::RenderContext,
 };
 
+pub(crate) fn render_macro<'a>(
+    ctx: RenderContext<'a>,
+    name: String,
+    macro_: hir::MacroDef,
+) -> Option<CompletionItem> {
+    MacroRender::new(ctx, name, macro_).render()
+}
+
 #[derive(Debug)]
-pub(crate) struct MacroRender<'a> {
+struct MacroRender<'a> {
     ctx: RenderContext<'a>,
     name: String,
     macro_: hir::MacroDef,
@@ -20,11 +28,7 @@ pub(crate) struct MacroRender<'a> {
 }
 
 impl<'a> MacroRender<'a> {
-    pub(crate) fn new(
-        ctx: RenderContext<'a>,
-        name: String,
-        macro_: hir::MacroDef,
-    ) -> MacroRender<'a> {
+    fn new(ctx: RenderContext<'a>, name: String, macro_: hir::MacroDef) -> MacroRender<'a> {
         let docs = ctx.docs(macro_);
         let docs_str = docs.as_ref().map_or("", |s| s.as_str());
         let (bra, ket) = guess_macro_braces(&name, docs_str);
@@ -32,7 +36,7 @@ impl<'a> MacroRender<'a> {
         MacroRender { ctx, name, macro_, docs, bra, ket }
     }
 
-    pub(crate) fn render(&self) -> Option<CompletionItem> {
+    fn render(&self) -> Option<CompletionItem> {
         // FIXME: Currently proc-macro do not have ast-node,
         // such that it does not have source
         if self.macro_.is_proc_macro() {

crates/completion/src/render/type_alias.rs

@@ -11,20 +11,27 @@ use crate::{
     render::RenderContext,
 };
 
+pub(crate) fn render_type_alias<'a>(
+    ctx: RenderContext<'a>,
+    type_alias: hir::TypeAlias,
+) -> Option<CompletionItem> {
+    TypeAliasRender::new(ctx, type_alias).render()
+}
+
 #[derive(Debug)]
-pub(crate) struct TypeAliasRender<'a> {
+struct TypeAliasRender<'a> {
     ctx: RenderContext<'a>,
     type_alias: hir::TypeAlias,
     ast_node: TypeAlias,
 }
 
 impl<'a> TypeAliasRender<'a> {
-    pub(crate) fn new(ctx: RenderContext<'a>, type_alias: hir::TypeAlias) -> TypeAliasRender<'a> {
+    fn new(ctx: RenderContext<'a>, type_alias: hir::TypeAlias) -> TypeAliasRender<'a> {
         let ast_node = type_alias.source(ctx.db()).value;
         TypeAliasRender { ctx, type_alias, ast_node }
     }
 
-    pub(crate) fn render(self) -> Option<CompletionItem> {
+    fn render(self) -> Option<CompletionItem> {
         let name = self.name()?;
         let detail = self.detail();