complete raw identifier with "r#" prefix

crates/ide-completion/src/render/const_.rs

@@ -12,7 +12,8 @@ pub(crate) fn render_const(ctx: RenderContext<'_>, const_: hir::Const) -> Option
 
 fn render(ctx: RenderContext<'_>, const_: hir::Const) -> Option<CompletionItem> {
     let db = ctx.db();
-    let name = const_.name(db)?.to_smol_str();
+    let name = const_.name(db)?;
+    let (name, escaped_name) = (name.to_smol_str(), name.escaped().to_smol_str());
     let detail = const_.display(db).to_string();
 
     let mut item = CompletionItem::new(SymbolKind::Const, ctx.source_range(), name.clone());
@@ -24,9 +25,9 @@ fn render(ctx: RenderContext<'_>, const_: hir::Const) -> Option<CompletionItem>
     if let Some(actm) = const_.as_assoc_item(db) {
         if let Some(trt) = actm.containing_trait_or_trait_impl(db) {
             item.trait_name(trt.name(db).to_smol_str());
-            item.insert_text(name);
         }
     }
+    item.insert_text(escaped_name);
 
     Some(item.build())
 }

crates/ide-completion/src/render/function.rs

@@ -50,9 +50,12 @@ fn render(
 
     let name = local_name.unwrap_or_else(|| func.name(db));
 
-    let call = match &func_kind {
-        FuncKind::Method(_, Some(receiver)) => format!("{}.{}", receiver, &name).into(),
-        _ => name.to_smol_str(),
+    let (call, escaped_call) = match &func_kind {
+        FuncKind::Method(_, Some(receiver)) => (
+            format!("{}.{}", receiver, &name).into(),
+            format!("{}.{}", receiver.escaped(), name.escaped()).into(),
+        ),
+        _ => (name.to_smol_str(), name.escaped().to_smol_str()),
     };
     let mut item = CompletionItem::new(
         if func.self_param(db).is_some() {
@@ -115,7 +118,15 @@ fn render(
                 if let Some((self_param, params)) =
                     params(ctx.completion, func, &func_kind, has_dot_receiver)
                 {
-                    add_call_parens(&mut item, completion, cap, call, self_param, params);
+                    add_call_parens(
+                        &mut item,
+                        completion,
+                        cap,
+                        call,
+                        escaped_call,
+                        self_param,
+                        params,
+                    );
                 }
             }
         }
@@ -142,13 +153,14 @@ pub(super) fn add_call_parens<'b>(
     ctx: &CompletionContext,
     cap: SnippetCap,
     name: SmolStr,
+    escaped_name: SmolStr,
     self_param: Option<hir::SelfParam>,
     params: Vec<hir::Param>,
 ) -> &'b mut Builder {
     cov_mark::hit!(inserts_parens_for_function_calls);
 
     let (snippet, label_suffix) = if self_param.is_none() && params.is_empty() {
-        (format!("{}()$0", name), "()")
+        (format!("{}()$0", escaped_name), "()")
     } else {
         builder.trigger_call_info();
         let snippet = if let Some(CallableSnippets::FillArguments) = ctx.config.callable {
@@ -179,19 +191,19 @@ pub(super) fn add_call_parens<'b>(
                 Some(self_param) => {
                     format!(
                         "{}(${{1:{}}}{}{})$0",
-                        name,
+                        escaped_name,
                         self_param.display(ctx.db),
                         if params.is_empty() { "" } else { ", " },
                         function_params_snippet
                     )
                 }
                 None => {
-                    format!("{}({})$0", name, function_params_snippet)
+                    format!("{}({})$0", escaped_name, function_params_snippet)
                 }
             }
         } else {
             cov_mark::hit!(suppress_arg_snippets);
-            format!("{}($0)", name)
+            format!("{}($0)", escaped_name)
         };
 
         (snippet, "(…)")

crates/ide-completion/src/render/literal.rs

@@ -72,17 +72,21 @@ fn render(
         }
         None => (name.clone().into(), name.into(), false),
     };
-    let qualified_name = qualified_name.to_string();
+    let (qualified_name, escaped_qualified_name) =
+        (qualified_name.to_string(), qualified_name.escaped().to_string());
     let snippet_cap = ctx.snippet_cap();
 
     let mut rendered = match kind {
         StructKind::Tuple if should_add_parens => {
-            render_tuple_lit(db, snippet_cap, &fields, &qualified_name)
+            render_tuple_lit(db, snippet_cap, &fields, &escaped_qualified_name)
         }
         StructKind::Record if should_add_parens => {
-            render_record_lit(db, snippet_cap, &fields, &qualified_name)
+            render_record_lit(db, snippet_cap, &fields, &escaped_qualified_name)
         }
-        _ => RenderedLiteral { literal: qualified_name.clone(), detail: qualified_name.clone() },
+        _ => RenderedLiteral {
+            literal: escaped_qualified_name.clone(),
+            detail: escaped_qualified_name.clone(),
+        },
     };
 
     if snippet_cap.is_some() {

crates/ide-completion/src/render/macro_.rs

@@ -46,7 +46,7 @@ fn render(
         ctx.source_range()
     };
 
-    let name = name.to_smol_str();
+    let (name, escaped_name) = (name.to_smol_str(), name.escaped().to_smol_str());
     let docs = ctx.docs(macro_);
     let docs_str = docs.as_ref().map(Documentation::as_str).unwrap_or_default();
     let is_fn_like = macro_.is_fn_like(completion.db);
@@ -64,20 +64,18 @@ fn render(
         .set_documentation(docs)
         .set_relevance(ctx.completion_relevance());
 
-    let name = &*name;
     match ctx.snippet_cap() {
         Some(cap) if needs_bang && !has_call_parens => {
-            let snippet = format!("{}!{}$0{}", name, bra, ket);
-            let lookup = banged_name(name);
+            let snippet = format!("{}!{}$0{}", escaped_name, bra, ket);
+            let lookup = banged_name(&name);
             item.insert_snippet(cap, snippet).lookup_by(lookup);
         }
         _ if needs_bang => {
-            let banged_name = banged_name(name);
-            item.insert_text(banged_name.clone()).lookup_by(banged_name);
+            item.insert_text(banged_name(&escaped_name)).lookup_by(banged_name(&name));
         }
         _ => {
             cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
-            item.insert_text(name);
+            item.insert_text(escaped_name);
         }
     };
     if let Some(import_to_add) = ctx.import_to_add {

crates/ide-completion/src/render/pattern.rs

@@ -27,11 +27,12 @@ pub(crate) fn render_struct_pat(
         return None;
     }
 
-    let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_smol_str();
+    let name = local_name.unwrap_or_else(|| strukt.name(ctx.db()));
+    let (name, escaped_name) = (name.to_smol_str(), name.escaped().to_smol_str());
     let pat = render_pat(
         &ctx,
         pattern_ctx,
-        &name,
+        &escaped_name,
         strukt.kind(ctx.db()),
         &visible_fields,
         fields_omitted,
@@ -52,14 +53,17 @@ pub(crate) fn render_variant_pat(
     let fields = variant.fields(ctx.db());
     let (visible_fields, fields_omitted) = visible_fields(ctx.completion, &fields, variant)?;
 
-    let name = match path {
-        Some(path) => path.to_string().into(),
-        None => local_name.unwrap_or_else(|| variant.name(ctx.db())).to_smol_str(),
+    let (name, escaped_name) = match path {
+        Some(path) => (path.to_string().into(), path.escaped().to_string().into()),
+        None => {
+            let name = local_name.unwrap_or_else(|| variant.name(ctx.db()));
+            (name.to_smol_str(), name.escaped().to_smol_str())
+        }
     };
     let pat = render_pat(
         &ctx,
         pattern_ctx,
-        &name,
+        &escaped_name,
         variant.kind(ctx.db()),
         &visible_fields,
         fields_omitted,

crates/ide-completion/src/render/type_alias.rs

@@ -29,10 +29,14 @@ fn render(
 ) -> Option<CompletionItem> {
     let db = ctx.db();
 
-    let name = if with_eq {
-        SmolStr::from_iter([&*type_alias.name(db).to_smol_str(), " = "])
+    let name = type_alias.name(db);
+    let (name, escaped_name) = if with_eq {
+        (
+            SmolStr::from_iter([&name.to_smol_str(), " = "]),
+            SmolStr::from_iter([&name.escaped().to_smol_str(), " = "]),
+        )
     } else {
-        type_alias.name(db).to_smol_str()
+        (name.to_smol_str(), name.escaped().to_smol_str())
     };
     let detail = type_alias.display(db).to_string();
 
@@ -45,9 +49,9 @@ fn render(
     if let Some(actm) = type_alias.as_assoc_item(db) {
         if let Some(trt) = actm.containing_trait_or_trait_impl(db) {
             item.trait_name(trt.name(db).to_smol_str());
-            item.insert_text(name);
         }
     }
+    item.insert_text(escaped_name);
 
     Some(item.build())
 }

crates/ide-completion/src/render/union_literal.rs

@@ -18,17 +18,17 @@ pub(crate) fn render_union_literal(
     path: Option<hir::ModPath>,
     local_name: Option<Name>,
 ) -> Option<CompletionItem> {
-    let name = local_name.unwrap_or_else(|| un.name(ctx.db())).to_smol_str();
+    let name = local_name.unwrap_or_else(|| un.name(ctx.db()));
 
-    let qualified_name = match path {
-        Some(p) => p.to_string(),
-        None => name.to_string(),
+    let (qualified_name, escaped_qualified_name) = match path {
+        Some(p) => (p.to_string(), p.escaped().to_string()),
+        None => (name.to_string(), name.escaped().to_string()),
     };
 
     let mut item = CompletionItem::new(
         CompletionItemKind::SymbolKind(SymbolKind::Union),
         ctx.source_range(),
-        format_literal_label(&name, StructKind::Record),
+        format_literal_label(&name.to_smol_str(), StructKind::Record),
     );
 
     let fields = un.fields(ctx.db());
@@ -41,16 +41,16 @@ pub(crate) fn render_union_literal(
     let literal = if ctx.snippet_cap().is_some() {
         format!(
             "{} {{ ${{1|{}|}}: ${{2:()}} }}$0",
-            qualified_name,
-            fields.iter().map(|field| field.name(ctx.db())).format(",")
+            escaped_qualified_name,
+            fields.iter().map(|field| field.name(ctx.db()).escaped().to_smol_str()).format(",")
         )
     } else {
         format!(
             "{} {{ {} }}",
-            qualified_name,
-            fields
-                .iter()
-                .format_with(", ", |field, f| { f(&format_args!("{}: ()", field.name(ctx.db()))) })
+            escaped_qualified_name,
+            fields.iter().format_with(", ", |field, f| {
+                f(&format_args!("{}: ()", field.name(ctx.db()).escaped()))
+            })
         )
     };
 

crates/ide-completion/src/render/variant.rs

@@ -24,9 +24,9 @@ pub(crate) fn render_record_lit(
 ) -> RenderedLiteral {
     let completions = fields.iter().enumerate().format_with(", ", |(idx, field), f| {
         if snippet_cap.is_some() {
-            f(&format_args!("{}: ${{{}:()}}", field.name(db), idx + 1))
+            f(&format_args!("{}: ${{{}:()}}", field.name(db).escaped(), idx + 1))
         } else {
-            f(&format_args!("{}: ()", field.name(db)))
+            f(&format_args!("{}: ()", field.name(db).escaped()))
         }
     });