proc_macro: stop using a remote object handle for Ident

This requires a dependency on `unicode-normalization` and `rustc_lexer`, which
is currently not possible for `proc_macro`. Instead, a second `extern "C" fn`
is provided by the compiler server to perform these steps from any thread.

String values are interned in both the server and client, meaning that
identifiers can be stringified without any RPC roundtrips without substantially
inflating their size.

RPC messages passing symbols include the full un-interned value, and are
re-interned on the receiving side. This could potentially be optimized in the
future.

The symbol infrastructure will alwo be used for literals in a following part.

Author: mystor

Cargo.lock

@@ -3798,6 +3798,7 @@ dependencies = [
  "rustc_span",
  "smallvec",
  "tracing",
+ "unicode-normalization",
 ]
 
 [[package]]

compiler/rustc_expand/Cargo.toml

@@ -24,3 +24,4 @@ rustc_parse = { path = "../rustc_parse" }
 rustc_session = { path = "../rustc_session" }
 smallvec = { version = "1.6.1", features = ["union", "may_dangle"] }
 rustc_ast = { path = "../rustc_ast" }
+unicode-normalization = "0.1.11"

compiler/rustc_expand/src/proc_macro_server.rs

@@ -7,17 +7,16 @@ use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::{Diagnostic, MultiSpan, PResult};
-use rustc_parse::lexer::nfc_normalize;
 use rustc_parse::parse_stream_from_source_str;
 use rustc_session::parse::ParseSess;
 use rustc_span::def_id::CrateNum;
-use rustc_span::symbol::{self, kw, sym, Symbol};
+use rustc_span::symbol::{self, sym, Symbol};
 use rustc_span::{BytePos, FileName, Pos, SourceFile, Span};
 
-use pm::bridge::{server, DelimSpan, Group, Punct, TokenTree};
+use pm::bridge::{server, DelimSpan, Group, Ident, Punct, TokenTree};
 use pm::{Delimiter, Level, LineColumn};
+use std::ascii;
 use std::ops::Bound;
-use std::{ascii, panic};
 
 trait FromInternal<T> {
     fn from_internal(x: T) -> Self;
@@ -50,7 +49,7 @@ impl ToInternal<token::Delimiter> for Delimiter {
 }
 
 impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)>
-    for Vec<TokenTree<TokenStream, Span, Ident, Literal>>
+    for Vec<TokenTree<TokenStream, Span, Symbol, Literal>>
 {
     fn from_internal((stream, rustc): (TokenStream, &mut Rustc<'_, '_>)) -> Self {
         use rustc_ast::token::*;
@@ -84,9 +83,6 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)>
                         span,
                     }))
                 );
-                ($ty:ident::$method:ident($($value:expr),*)) => (
-                    trees.push(TokenTree::$ty(self::$ty::$method($($value,)* span)))
-                );
             }
             macro_rules! op {
                 ($a:expr) => {{
@@ -152,12 +148,11 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)>
                 Question => op!('?'),
                 SingleQuote => op!('\''),
 
-                Ident(name, false) if name == kw::DollarCrate => tt!(Ident::dollar_crate()),
-                Ident(name, is_raw) => tt!(Ident::new(rustc.sess(), name, is_raw)),
+                Ident(sym, is_raw) => tt!(Ident { sym, is_raw }),
                 Lifetime(name) => {
                     let ident = symbol::Ident::new(name, span).without_first_quote();
                     tt!(Punct { ch: '\'', joint: true });
-                    tt!(Ident::new(rustc.sess(), ident.name, false));
+                    tt!(Ident { sym: ident.name, is_raw: false });
                 }
                 Literal(lit) => tt!(Literal { lit }),
                 DocComment(_, attr_style, data) => {
@@ -185,7 +180,7 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)>
                 }
 
                 Interpolated(nt) if let NtIdent(ident, is_raw) = *nt => {
-                    trees.push(TokenTree::Ident(Ident::new(rustc.sess(), ident.name, is_raw, ident.span)))
+                    trees.push(TokenTree::Ident(Ident { sym: ident.name, is_raw, span: ident.span }))
                 }
 
                 Interpolated(nt) => {
@@ -209,7 +204,7 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)>
     }
 }
 
-impl ToInternal<TokenStream> for TokenTree<TokenStream, Span, Ident, Literal> {
+impl ToInternal<TokenStream> for TokenTree<TokenStream, Span, Symbol, Literal> {
     fn to_internal(self) -> TokenStream {
         use rustc_ast::token::*;
 
@@ -298,32 +293,6 @@ impl ToInternal<rustc_errors::Level> for Level {
 
 pub struct FreeFunctions;
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Ident {
-    sym: Symbol,
-    is_raw: bool,
-    span: Span,
-}
-
-impl Ident {
-    fn new(sess: &ParseSess, sym: Symbol, is_raw: bool, span: Span) -> Ident {
-        let sym = nfc_normalize(sym.as_str());
-        let string = sym.as_str();
-        if !rustc_lexer::is_ident(string) {
-            panic!("`{:?}` is not a valid identifier", string)
-        }
-        if is_raw && !sym.can_be_raw() {
-            panic!("`{}` cannot be a raw identifier", string);
-        }
-        sess.symbol_gallery.insert(sym, span);
-        Ident { sym, is_raw, span }
-    }
-    fn dollar_crate(span: Span) -> Ident {
-        // `$crate` is accepted as an ident only if it comes from the compiler.
-        Ident { sym: kw::DollarCrate, is_raw: false, span }
-    }
-}
-
 // FIXME(eddyb) `Literal` should not expose internal `Debug` impls.
 #[derive(Clone, Debug)]
 pub struct Literal {
@@ -368,12 +337,12 @@ impl<'a, 'b> Rustc<'a, 'b> {
 impl server::Types for Rustc<'_, '_> {
     type FreeFunctions = FreeFunctions;
     type TokenStream = TokenStream;
-    type Ident = Ident;
     type Literal = Literal;
     type SourceFile = Lrc<SourceFile>;
     type MultiSpan = Vec<Span>;
     type Diagnostic = Diagnostic;
     type Span = Span;
+    type Symbol = Symbol;
 }
 
 impl server::FreeFunctions for Rustc<'_, '_> {
@@ -456,14 +425,14 @@ impl server::TokenStream for Rustc<'_, '_> {
     }
     fn from_token_tree(
         &mut self,
-        tree: TokenTree<Self::TokenStream, Self::Span, Self::Ident, Self::Literal>,
+        tree: TokenTree<Self::TokenStream, Self::Span, Self::Symbol, Self::Literal>,
     ) -> Self::TokenStream {
         tree.to_internal()
     }
     fn concat_trees(
         &mut self,
         base: Option<Self::TokenStream>,
-        trees: Vec<TokenTree<Self::TokenStream, Self::Span, Self::Ident, Self::Literal>>,
+        trees: Vec<TokenTree<Self::TokenStream, Self::Span, Self::Symbol, Self::Literal>>,
     ) -> Self::TokenStream {
         let mut builder = tokenstream::TokenStreamBuilder::new();
         if let Some(base) = base {
@@ -491,23 +460,11 @@ impl server::TokenStream for Rustc<'_, '_> {
     fn into_iter(
         &mut self,
         stream: Self::TokenStream,
-    ) -> Vec<TokenTree<Self::TokenStream, Self::Span, Self::Ident, Self::Literal>> {
+    ) -> Vec<TokenTree<Self::TokenStream, Self::Span, Self::Symbol, Self::Literal>> {
         FromInternal::from_internal((stream, self))
     }
 }
 
-impl server::Ident for Rustc<'_, '_> {
-    fn new(&mut self, string: &str, span: Self::Span, is_raw: bool) -> Self::Ident {
-        Ident::new(self.sess(), Symbol::intern(string), is_raw, span)
-    }
-    fn span(&mut self, ident: Self::Ident) -> Self::Span {
-        ident.span
-    }
-    fn with_span(&mut self, ident: Self::Ident, span: Self::Span) -> Self::Ident {
-        Ident { span, ..ident }
-    }
-}
-
 impl server::Literal for Rustc<'_, '_> {
     fn from_str(&mut self, s: &str) -> Result<Self::Literal, ()> {
         let name = FileName::proc_macro_source_code(s);
@@ -789,4 +746,26 @@ impl server::Context for Rustc<'_, '_> {
     fn mixed_site(&mut self) -> Self::Span {
         self.mixed_site
     }
+
+    // NOTE: May be run on any thread, so cannot use `nfc_normalize`
+    fn validate_ident(s: &str) -> Result<Option<String>, ()> {
+        use unicode_normalization::{is_nfc_quick, IsNormalized, UnicodeNormalization};
+        let normalized: Option<String> = match is_nfc_quick(s.chars()) {
+            IsNormalized::Yes => None,
+            _ => Some(s.chars().nfc().collect()),
+        };
+        if rustc_lexer::is_ident(normalized.as_ref().map(|s| &s[..]).unwrap_or(s)) {
+            Ok(normalized)
+        } else {
+            Err(())
+        }
+    }
+
+    fn intern_symbol(string: &str) -> Self::Symbol {
+        Symbol::intern(string)
+    }
+
+    fn with_symbol_string(symbol: &Self::Symbol, f: impl FnOnce(&str)) {
+        f(&symbol.as_str())
+    }
 }

library/proc_macro/src/bridge/buffer.rs

@@ -1,10 +1,41 @@
 //! Buffer management for same-process client<->server communication.
 
 use std::io::{self, Write};
+use std::marker::PhantomData;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::slice;
 
+#[repr(C)]
+pub struct Slice<'a> {
+    data: *const u8,
+    len: usize,
+    _marker: PhantomData<&'a [u8]>,
+}
+
+unsafe impl<'a> Send for Slice<'a> {}
+unsafe impl<'a> Sync for Slice<'a> {}
+
+impl<'a> Copy for Slice<'a> {}
+impl<'a> Clone for Slice<'a> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a> From<&'a [u8]> for Slice<'a> {
+    fn from(xs: &'a [u8]) -> Self {
+        Slice { data: xs.as_ptr(), len: xs.len(), _marker: PhantomData }
+    }
+}
+
+impl<'a> Deref for Slice<'a> {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.data, self.len) }
+    }
+}
+
 #[repr(C)]
 pub struct Buffer {
     data: *mut u8,