Implement rough symbol interning infra

Author: Veykril

Cargo.lock

@@ -2,6 +2,7 @@
 
 use std::fmt;
 
+use intern::Symbol;
 use syntax::{ast, format_smolstr, utils::is_raw_identifier, SmolStr};
 
 /// `Name` is a wrapper around string, which is used in hir for both references
@@ -12,7 +13,10 @@ use syntax::{ast, format_smolstr, utils::is_raw_identifier, SmolStr};
 /// is a raw identifier. Use [`unescaped()`][Name::unescaped] when you need the
 /// name without "r#".
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Name(Repr);
+pub struct Name {
+    symbol: Symbol,
+    span: (),
+}
 
 /// Wrapper of `Name` to print the name without "r#" even when it is a raw identifier.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -28,15 +32,11 @@ impl UnescapedName<'_> {
     /// 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 let Some(stripped) = it.strip_prefix("r#") {
-                    SmolStr::new(stripped)
-                } else {
-                    it.clone()
-                }
-            }
-            Repr::TupleField(it) => SmolStr::new(it.to_string()),
+        let it = self.0.symbol.as_str();
+        if let Some(stripped) = it.strip_prefix("r#") {
+            SmolStr::new(stripped)
+        } else {
+            it.into()
         }
     }
 
@@ -51,34 +51,39 @@ impl Name {
     /// Hopefully, this should allow us to integrate hygiene cleaner in the
     /// future, and to switch to interned representation of names.
     const fn new_text(text: SmolStr) -> Name {
-        Name(Repr::Text(text))
+        Name { symbol: Symbol::intern(text.as_str()), span: () }
     }
 
     // FIXME: See above, unfortunately some places really need this right now
     #[doc(hidden)]
     pub const fn new_text_dont_use(text: SmolStr) -> Name {
-        Name(Repr::Text(text))
+        Name { symbol: Symbol::intern(text.as_str()), span: () }
     }
 
     pub fn new_tuple_field(idx: usize) -> Name {
-        Name(Repr::TupleField(idx))
+        Name { symbol: Symbol::intern(&idx.to_string()), span: () }
     }
 
     pub fn new_lifetime(lt: &ast::Lifetime) -> Name {
-        Self::new_text(lt.text().into())
+        Name { symbol: Symbol::intern(lt.text().as_str()), span: () }
     }
 
     /// Shortcut to create a name from a string literal.
     const fn new_static(text: &'static str) -> Name {
-        Name::new_text(SmolStr::new_static(text))
+        todo!()
+    }
+
+    /// Shortcut to create a name from a string literal.
+    fn new_ref(text: &str) -> Name {
+        Name { symbol: Symbol::intern(text), span: () }
     }
 
     /// Resolve a name from the text of token.
     fn resolve(raw_text: &str) -> Name {
         match raw_text.strip_prefix("r#") {
             // When `raw_text` starts with "r#" but the name does not coincide with any
             // keyword, we never need the prefix so we strip it.
-            Some(text) if !is_raw_identifier(text) => Name::new_text(SmolStr::new(text)),
+            Some(text) if !is_raw_identifier(text) => Name::new_ref(text),
             // Keywords (in the current edition) *can* be used as a name in earlier editions of
             // Rust, e.g. "try" in Rust 2015. Even in such cases, we keep track of them in their
             // escaped form.
@@ -120,47 +125,32 @@ impl Name {
 
     /// Returns the tuple index this name represents if it is a tuple field.
     pub fn as_tuple_index(&self) -> Option<usize> {
-        match self.0 {
-            Repr::TupleField(idx) => Some(idx),
-            _ => None,
-        }
+        self.symbol.as_str().parse().ok()
     }
 
     /// Returns the text this name represents if it isn't a tuple field.
-    pub fn as_text(&self) -> Option<SmolStr> {
-        match &self.0 {
-            Repr::Text(it) => Some(it.clone()),
-            _ => None,
-        }
+    pub fn as_text(&self) -> SmolStr {
+        self.symbol.as_str().into()
     }
 
     /// Returns the text this name represents if it isn't a tuple field.
-    pub fn as_str(&self) -> Option<&str> {
-        match &self.0 {
-            Repr::Text(it) => Some(it),
-            _ => None,
-        }
+    pub fn as_str(&self) -> &str {
+        self.symbol.as_str()
     }
 
     /// 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 {
-            Repr::Text(it) => it.clone(),
-            Repr::TupleField(it) => SmolStr::new(it.to_string()),
-        }
+        self.as_text()
     }
 
     pub fn unescaped(&self) -> UnescapedName<'_> {
         UnescapedName(self)
     }
 
     pub fn is_escaped(&self) -> bool {
-        match &self.0 {
-            Repr::Text(it) => it.starts_with("r#"),
-            Repr::TupleField(_) => false,
-        }
+        self.symbol.as_str().starts_with("r#")
     }
 
     pub fn display<'a>(&'a self, db: &dyn crate::db::ExpandDatabase) -> impl fmt::Display + 'a {
@@ -175,10 +165,7 @@ struct Display<'a> {
 
 impl fmt::Display for Display<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.name.0 {
-            Repr::Text(text) => fmt::Display::fmt(&text, f),
-            Repr::TupleField(idx) => fmt::Display::fmt(&idx, f),
-        }
+        fmt::Display::fmt(self.name.symbol.as_str(), f)
     }
 }
 
@@ -188,13 +175,9 @@ struct UnescapedDisplay<'a> {
 
 impl fmt::Display for UnescapedDisplay<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.name.0 .0 {
-            Repr::Text(text) => {
-                let text = text.strip_prefix("r#").unwrap_or(text);
-                fmt::Display::fmt(&text, f)
-            }
-            Repr::TupleField(idx) => fmt::Display::fmt(&idx, f),
-        }
+        let symbol = &self.name.0.symbol.as_str();
+        let text = symbol.strip_prefix("r#").unwrap_or(symbol);
+        fmt::Display::fmt(&text, f)
     }
 }
 

crates/hir-expand/src/name.rs

@@ -18,6 +18,7 @@ dashmap.workspace = true
 hashbrown.workspace = true
 rustc-hash.workspace = true
 triomphe.workspace = true
+sptr = "0.3.2"
 
 [lints]
-workspace = true
+workspace = true

crates/intern/Cargo.toml

@@ -20,6 +20,9 @@ type Guard<T> = dashmap::RwLockWriteGuard<
     HashMap<Arc<T>, SharedValue<()>, BuildHasherDefault<FxHasher>>,
 >;
 
+mod symbol;
+pub use self::symbol::{symbols, Symbol};
+
 pub struct Interned<T: Internable + ?Sized> {
     arc: Arc<T>,
 }