Replace some String usages with SmolStr in completions

[rust.git] / crates / ide_completion / src / render / pattern.rs

diff --git a/crates/ide_completion/src/render/pattern.rs b/crates/ide_completion/src/render/pattern.rs
index 4d8f2b17d91d81b5779edba5c18666585d1dbf78..e553ec8f860d8544e9ef216492284d4fa5accb75 100644 (file)
--- a/crates/ide_completion/src/render/pattern.rs
+++ b/crates/ide_completion/src/render/pattern.rs
@@ -3,26 +3,13 @@
 use hir::{db::HirDatabase, HasAttrs, HasVisibility, Name, StructKind};
 use ide_db::helpers::SnippetCap;
 use itertools::Itertools;
+use syntax::SmolStr;
 
-use crate::{item::CompletionKind, render::RenderContext, CompletionItem, CompletionItemKind};
-
-fn visible_fields(
-    ctx: &RenderContext<'_>,
-    fields: &[hir::Field],
-    item: impl HasAttrs,
-) -> Option<(Vec<hir::Field>, bool)> {
-    let module = ctx.completion.scope.module()?;
-    let n_fields = fields.len();
-    let fields = fields
-        .into_iter()
-        .filter(|field| field.is_visible_from(ctx.db(), module))
-        .copied()
-        .collect::<Vec<_>>();
-
-    let fields_omitted =
-        n_fields - fields.len() > 0 || item.attrs(ctx.db()).by_key("non_exhaustive").exists();
-    Some((fields, fields_omitted))
-}
+use crate::{
+    context::{ParamKind, PatternContext},
+    render::RenderContext,
+    CompletionItem, CompletionItemKind,
+};
 
 pub(crate) fn render_struct_pat(
     ctx: RenderContext<'_>,
@@ -39,7 +26,7 @@ pub(crate) fn render_struct_pat(
         return None;
     }
 
-    let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_string();
+    let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_smol_str();
     let pat = render_pat(&ctx, &name, strukt.kind(ctx.db()), &visible_fields, fields_omitted)?;
 
     Some(build_completion(ctx, name, pat, strukt))
@@ -57,8 +44,8 @@ pub(crate) fn render_variant_pat(
     let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, variant)?;
 
     let name = match &path {
-        Some(path) => path.to_string(),
-        None => local_name.unwrap_or_else(|| variant.name(ctx.db())).to_string(),
+        Some(path) => path.to_string().into(),
+        None => local_name.unwrap_or_else(|| variant.name(ctx.db())).to_smol_str(),
     };
     let pat = render_pat(&ctx, &name, variant.kind(ctx.db()), &visible_fields, fields_omitted)?;
 
@@ -67,22 +54,17 @@ pub(crate) fn render_variant_pat(
 
 fn build_completion(
     ctx: RenderContext<'_>,
-    name: String,
+    name: SmolStr,
     pat: String,
-    item: impl HasAttrs + Copy,
+    def: impl HasAttrs + Copy,
 ) -> CompletionItem {
-    let mut completion = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name);
-    completion
-        .kind(CompletionItemKind::Binding)
-        .set_documentation(ctx.docs(item))
-        .set_deprecated(ctx.is_deprecated(item))
-        .detail(&pat);
-    if let Some(snippet_cap) = ctx.snippet_cap() {
-        completion.insert_snippet(snippet_cap, pat);
-    } else {
-        completion.insert_text(pat);
+    let mut item = CompletionItem::new(CompletionItemKind::Binding, ctx.source_range(), name);
+    item.set_documentation(ctx.docs(def)).set_deprecated(ctx.is_deprecated(def)).detail(&pat);
+    match ctx.snippet_cap() {
+        Some(snippet_cap) => item.insert_snippet(snippet_cap, pat),
+        None => item.insert_text(pat),
     };
-    completion.build()
+    item.build()
 }
 
 fn render_pat(
@@ -94,18 +76,21 @@ fn render_pat(
 ) -> Option<String> {
     let mut pat = match kind {
         StructKind::Tuple if ctx.snippet_cap().is_some() => {
-            render_tuple_as_pat(&fields, &name, fields_omitted)
+            render_tuple_as_pat(fields, name, fields_omitted)
         }
         StructKind::Record => {
-            render_record_as_pat(ctx.db(), ctx.snippet_cap(), &fields, &name, fields_omitted)
+            render_record_as_pat(ctx.db(), ctx.snippet_cap(), fields, name, fields_omitted)
         }
         _ => return None,
     };
 
-    if ctx.completion.is_param {
+    if matches!(
+        ctx.completion.pattern_ctx,
+        Some(PatternContext { is_param: Some(ParamKind::Function), .. })
+    ) {
         pat.push(':');
         pat.push(' ');
-        pat.push_str(&name);
+        pat.push_str(name);
     }
     if ctx.snippet_cap().is_some() {
         pat.push_str("$0");
@@ -149,3 +134,21 @@ fn render_tuple_as_pat(fields: &[hir::Field], name: &str, fields_omitted: bool)
         name = name
     )
 }
+
+fn visible_fields(
+    ctx: &RenderContext<'_>,
+    fields: &[hir::Field],
+    item: impl HasAttrs,
+) -> Option<(Vec<hir::Field>, bool)> {
+    let module = ctx.completion.scope.module()?;
+    let n_fields = fields.len();
+    let fields = fields
+        .iter()
+        .filter(|field| field.is_visible_from(ctx.db(), module))
+        .copied()
+        .collect::<Vec<_>>();
+
+    let fields_omitted =
+        n_fields - fields.len() > 0 || item.attrs(ctx.db()).by_key("non_exhaustive").exists();
+    Some((fields, fields_omitted))
+}