Auto merge of rust-lang#12636 - xuhongxu96:fix-12148, r=Veykril

complete raw identifier with "r#" prefix

Fix rust-lang#12148

Escape Names and Paths used in `insert_text`/`insert_snippet` while rendering the completion items.

Author: bors

crates/hir-expand/src/mod_path.rs

@@ -20,6 +20,9 @@ pub struct ModPath {
     segments: Vec<Name>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct EscapedModPath<'a>(&'a ModPath);
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum PathKind {
     Plain,
@@ -97,10 +100,12 @@ impl ModPath {
             _ => None,
         }
     }
-}
 
-impl Display for ModPath {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    pub fn escaped(&self) -> EscapedModPath {
+        EscapedModPath(self)
+    }
+
+    fn _fmt(&self, f: &mut fmt::Formatter<'_>, escaped: bool) -> fmt::Result {
         let mut first_segment = true;
         let mut add_segment = |s| -> fmt::Result {
             if !first_segment {
@@ -127,12 +132,28 @@ impl Display for ModPath {
                 f.write_str("::")?;
             }
             first_segment = false;
-            segment.fmt(f)?;
+            if escaped {
+                segment.escaped().fmt(f)?
+            } else {
+                segment.fmt(f)?
+            };
         }
         Ok(())
     }
 }
 
+impl Display for ModPath {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self._fmt(f, false)
+    }
+}
+
+impl<'a> Display for EscapedModPath<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0._fmt(f, true)
+    }
+}
+
 impl From<Name> for ModPath {
     fn from(name: Name) -> ModPath {
         ModPath::from_segments(PathKind::Plain, iter::once(name))

crates/hir-expand/src/name.rs

@@ -2,14 +2,18 @@
 
 use std::fmt;
 
-use syntax::{ast, SmolStr};
+use syntax::{ast, SmolStr, SyntaxKind};
 
 /// `Name` is a wrapper around string, which is used in hir for both references
 /// and declarations. In theory, names should also carry hygiene info, but we are
 /// not there yet!
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Name(Repr);
 
+/// `EscapedName` will add a prefix "r#" to the wrapped `Name` when it is a raw identifier
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct EscapedName<'a>(&'a Name);
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 enum Repr {
     Text(SmolStr),
@@ -25,6 +29,51 @@ impl fmt::Display for Name {
     }
 }
 
+fn is_raw_identifier(name: &str) -> bool {
+    let is_keyword = SyntaxKind::from_keyword(name).is_some();
+    is_keyword && !matches!(name, "self" | "crate" | "super" | "Self")
+}
+
+impl<'a> fmt::Display for EscapedName<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &self.0 .0 {
+            Repr::Text(text) => {
+                if is_raw_identifier(text) {
+                    write!(f, "r#{}", &text)
+                } else {
+                    fmt::Display::fmt(&text, f)
+                }
+            }
+            Repr::TupleField(idx) => fmt::Display::fmt(&idx, f),
+        }
+    }
+}
+
+impl<'a> EscapedName<'a> {
+    pub fn is_escaped(&self) -> bool {
+        match &self.0 .0 {
+            Repr::Text(it) => is_raw_identifier(&it),
+            Repr::TupleField(_) => false,
+        }
+    }
+
+    /// Returns the textual representation of this name as a [`SmolStr`].
+    /// Prefer using this over [`ToString::to_string`] if possible as this conversion is cheaper in
+    /// the general case.
+    pub fn to_smol_str(&self) -> SmolStr {
+        match &self.0 .0 {
+            Repr::Text(it) => {
+                if is_raw_identifier(&it) {
+                    SmolStr::from_iter(["r#", &it])
+                } else {
+                    it.clone()
+                }
+            }
+            Repr::TupleField(it) => SmolStr::new(&it.to_string()),
+        }
+    }
+}
+
 impl Name {
     /// Note: this is private to make creating name from random string hard.
     /// Hopefully, this should allow us to integrate hygiene cleaner in the
@@ -92,6 +141,10 @@ impl Name {
             Repr::TupleField(it) => SmolStr::new(&it.to_string()),
         }
     }
+
+    pub fn escaped(&self) -> EscapedName {
+        EscapedName(self)
+    }
 }
 
 pub trait AsName {

crates/ide-completion/src/completions/item_list/trait_impl.rs

@@ -232,10 +232,11 @@ fn add_type_alias_impl(
     replacement_range: TextRange,
     type_alias: hir::TypeAlias,
 ) {
-    let alias_name = type_alias.name(ctx.db).to_smol_str();
+    let alias_name = type_alias.name(ctx.db);
+    let (alias_name, escaped_name) = (alias_name.to_smol_str(), alias_name.escaped().to_smol_str());
 
     let label = format!("type {} =", alias_name);
-    let replacement = format!("type {} = ", alias_name);
+    let replacement = format!("type {} = ", escaped_name);
 
     let mut item = CompletionItem::new(SymbolKind::TypeAlias, replacement_range, label);
     item.lookup_by(format!("type {}", alias_name))

crates/ide-completion/src/render.rs

@@ -116,7 +116,8 @@ pub(crate) fn render_field(
     ty: &hir::Type,
 ) -> CompletionItem {
     let is_deprecated = ctx.is_deprecated(field);
-    let name = field.name(ctx.db()).to_smol_str();
+    let name = field.name(ctx.db());
+    let (name, escaped_name) = (name.to_smol_str(), name.escaped().to_smol_str());
     let mut item = CompletionItem::new(
         SymbolKind::Field,
         ctx.source_range(),
@@ -131,10 +132,7 @@ pub(crate) fn render_field(
         .set_documentation(field.docs(ctx.db()))
         .set_deprecated(is_deprecated)
         .lookup_by(name.clone());
-    let is_keyword = SyntaxKind::from_keyword(name.as_str()).is_some();
-    if is_keyword && !matches!(name.as_str(), "self" | "crate" | "super" | "Self") {
-        item.insert_text(format!("r#{}", name));
-    }
+    item.insert_text(escaped_name);
     if let Some(receiver) = &dot_access.receiver {
         if let Some(ref_match) = compute_ref_match(ctx.completion, ty) {
             item.ref_match(ref_match, receiver.syntax().text_range().start());
@@ -235,7 +233,7 @@ fn render_resolution_pat(
         _ => (),
     }
 
-    render_resolution_simple_(ctx, local_name, import_to_add, resolution)
+    render_resolution_simple_(ctx, &local_name, import_to_add, resolution)
 }
 
 fn render_resolution_path(
@@ -274,7 +272,10 @@ fn render_resolution_path(
     let config = completion.config;
 
     let name = local_name.to_smol_str();
-    let mut item = render_resolution_simple_(ctx, local_name, import_to_add, resolution);
+    let mut item = render_resolution_simple_(ctx, &local_name, import_to_add, resolution);
+    if local_name.escaped().is_escaped() {
+        item.insert_text(local_name.escaped().to_smol_str());
+    }
     // Add `<>` for generic types
     let type_path_no_ty_args = matches!(
         path_ctx,
@@ -295,7 +296,7 @@ fn render_resolution_path(
                 item.lookup_by(name.clone())
                     .label(SmolStr::from_iter([&name, "<…>"]))
                     .trigger_call_info()
-                    .insert_snippet(cap, format!("{}<$0>", name));
+                    .insert_snippet(cap, format!("{}<$0>", local_name.escaped()));
             }
         }
     }
@@ -321,7 +322,7 @@ fn render_resolution_path(
 
 fn render_resolution_simple_(
     ctx: RenderContext<'_>,
-    local_name: hir::Name,
+    local_name: &hir::Name,
     import_to_add: Option<LocatedImport>,
     resolution: ScopeDef,
 ) -> Builder {
@@ -1725,4 +1726,149 @@ fn f() {
             "#]],
         );
     }
+
+    #[test]
+    fn completes_struct_with_raw_identifier() {
+        check_edit(
+            "type",
+            r#"
+mod m { pub struct r#type {} }
+fn main() {
+    let r#type = m::t$0;
+}
+"#,
+            r#"
+mod m { pub struct r#type {} }
+fn main() {
+    let r#type = m::r#type;
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn completes_fn_with_raw_identifier() {
+        check_edit(
+            "type",
+            r#"
+mod m { pub fn r#type {} }
+fn main() {
+    m::t$0
+}
+"#,
+            r#"
+mod m { pub fn r#type {} }
+fn main() {
+    m::r#type()$0
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn completes_macro_with_raw_identifier() {
+        check_edit(
+            "let!",
+            r#"
+macro_rules! r#let { () => {} }
+fn main() {
+    $0
+}
+"#,
+            r#"
+macro_rules! r#let { () => {} }
+fn main() {
+    r#let!($0)
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn completes_variant_with_raw_identifier() {
+        check_edit(
+            "type",
+            r#"
+enum A { r#type }
+fn main() {
+    let a = A::t$0
+}
+"#,
+            r#"
+enum A { r#type }
+fn main() {
+    let a = A::r#type$0
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn completes_field_with_raw_identifier() {
+        check_edit(
+            "fn",
+            r#"
+mod r#type {
+    pub struct r#struct {
+        pub r#fn: u32
+    }
+}
+
+fn main() {
+    let a = r#type::r#struct {};
+    a.$0
+}
+"#,
+            r#"
+mod r#type {
+    pub struct r#struct {
+        pub r#fn: u32
+    }
+}
+
+fn main() {
+    let a = r#type::r#struct {};
+    a.r#fn
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn completes_const_with_raw_identifier() {
+        check_edit(
+            "type",
+            r#"
+struct r#struct {}
+impl r#struct { pub const r#type: u8 = 1; }
+fn main() {
+    r#struct::t$0
+}
+"#,
+            r#"
+struct r#struct {}
+impl r#struct { pub const r#type: u8 = 1; }
+fn main() {
+    r#struct::r#type
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn completes_type_alias_with_raw_identifier() {
+        check_edit(
+            "type type",
+            r#"
+struct r#struct {}
+trait r#trait { type r#type; }
+impl r#trait for r#struct { type t$0 }
+"#,
+            r#"
+struct r#struct {}
+trait r#trait { type r#type; }
+impl r#trait for r#struct { type r#type = $0; }
+"#,
+        )
+    }
 }

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())
 }