add trait impls to proc_macro::Ident

Author: Qelxiros

library/proc_macro/src/bridge/ident.rs

@@ -0,0 +1,53 @@
+use std::{cmp, hash};
+
+#[derive(Copy, Clone)]
+pub struct Ident<Span, Symbol> {
+    pub sym: Symbol,
+    pub is_raw: bool,
+    pub span: Span,
+}
+
+impl<Span, Symbol: PartialEq> PartialEq<Self> for Ident<Span, Symbol> {
+    fn eq(&self, other: &Self) -> bool {
+        self.sym == other.sym && self.is_raw == other.is_raw
+    }
+}
+
+impl<Span, Symbol, T> PartialEq<T> for Ident<Span, Symbol>
+where
+    Symbol: PartialEq<str>,
+    T: AsRef<str> + ?Sized,
+{
+    fn eq(&self, other: &T) -> bool {
+        if self.is_raw {
+            if let Some(inner) = other.as_ref().strip_prefix("r#") {
+                self.sym == *inner
+            } else {
+                false
+            }
+        } else {
+            self.sym == *other.as_ref()
+        }
+    }
+}
+
+impl<Span, Symbol: Eq> Eq for Ident<Span, Symbol> {}
+
+impl<Span, Symbol: Ord> PartialOrd for Ident<Span, Symbol> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<Span, Symbol: Ord> Ord for Ident<Span, Symbol> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.sym.cmp(&other.sym).then_with(|| self.is_raw.cmp(&other.is_raw))
+    }
+}
+
+impl<Span, Symbol: hash::Hash> hash::Hash for Ident<Span, Symbol> {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.sym.hash(state);
+        self.is_raw.hash(state);
+    }
+}

library/proc_macro/src/bridge/mod.rs

@@ -151,6 +151,7 @@ mod closure;
 mod fxhash;
 #[forbid(unsafe_code)]
 mod handle;
+mod ident;
 #[macro_use]
 #[forbid(unsafe_code)]
 mod rpc;
@@ -162,6 +163,7 @@ pub mod server;
 mod symbol;
 
 use buffer::Buffer;
+pub use ident::Ident;
 pub use rpc::PanicMessage;
 use rpc::{Decode, DecodeMut, Encode, Reader, Writer};
 
@@ -471,13 +473,6 @@ pub struct Punct<Span> {
 
 compound_traits!(struct Punct<Span> { ch, joint, span });
 
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct Ident<Span, Symbol> {
-    pub sym: Symbol,
-    pub is_raw: bool,
-    pub span: Span,
-}
-
 compound_traits!(struct Ident<Span, Symbol> { sym, is_raw, span });
 
 #[derive(Clone, Eq, PartialEq)]

library/proc_macro/src/bridge/symbol.rs

@@ -11,12 +11,12 @@
 
 use std::cell::RefCell;
 use std::num::NonZero;
-use std::str;
+use std::{cmp, str};
 
 use super::*;
 
 /// Handle for a symbol string stored within the Interner.
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone)]
 pub struct Symbol(NonZero<u32>);
 
 impl !Send for Symbol {}
@@ -97,6 +97,38 @@ impl fmt::Display for Symbol {
     }
 }
 
+impl PartialEq<Self> for Symbol {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl PartialEq<str> for Symbol {
+    fn eq(&self, other: &str) -> bool {
+        self.with(|s| s == other)
+    }
+}
+
+impl Eq for Symbol {}
+
+impl Hash for Symbol {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
+
+impl PartialOrd for Symbol {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Symbol {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.with(|s| other.with(|o| s.cmp(o)))
+    }
+}
+
 impl<S> Encode<S> for Symbol {
     fn encode(self, w: &mut Writer, s: &mut S) {
         self.with(|sym| sym.encode(w, s))

library/proc_macro/src/lib.rs

@@ -1018,7 +1018,7 @@ impl PartialEq<Punct> for char {
 }
 
 /// An identifier (`ident`).
-#[derive(Clone)]
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 pub struct Ident(bridge::Ident<bridge::client::Span, bridge::client::Symbol>);
 
@@ -1100,6 +1100,13 @@ impl fmt::Debug for Ident {
     }
 }
 
+#[stable(feature = "proc_macro_ident_impls", since = "CURRENT_RUSTC_VERSION")]
+impl<T: AsRef<str> + ?Sized> PartialEq<T> for Ident {
+    fn eq(&self, other: &T) -> bool {
+        self.0 == other
+    }
+}
+
 /// A literal string (`"hello"`), byte string (`b"hello"`), C string (`c"hello"`),
 /// character (`'a'`), byte character (`b'a'`), an integer or floating point number
 /// with or without a suffix (`1`, `1u8`, `2.3`, `2.3f32`).

src/tools/clippy/tests/ui/auxiliary/proc_macros.rs

@@ -465,7 +465,7 @@ impl Expander {
             } else if let TT::Punct(p) = &input.tt
                 && p.as_char() == '!'
                 && let TT::Ident(name) = &tt
-                && name.to_string() == "inline"
+                && *name == "inline"
             {
                 let g = expect_tt(
                     input.iter.next(),