reuse stuff

cyrgani · cyrgani · commit 5a1d52d36f7b · 2025-11-05T09:45:40.000+01:00
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
@@ -2,6 +2,7 @@
 
 use std::cell::RefCell;
 use std::marker::PhantomData;
+use std::num::NonZero;
 use std::sync::atomic::AtomicU32;
 
 use super::*;
@@ -110,6 +111,10 @@ impl Clone for TokenStream {
 }
 
 impl Span {
+    pub(crate) fn dummy() -> Span {
+        Span { handle: NonZero::new(1).unwrap() }
+    }
+
     pub(crate) fn def_site() -> Span {
         Bridge::with(|bridge| bridge.globals.def_site)
     }
@@ -197,7 +202,7 @@ mod state {
     thread_local! {
         static BRIDGE_STATE: Cell<*const ()> = const { Cell::new(ptr::null()) };
         static STANDALONE: RefCell<Bridge<'static>> = RefCell::new(standalone_bridge());
-        pub(super) static USE_STANDALONE: Cell<StandaloneLevel> = const { Cell::new(StandaloneLevel::Never) };
+        pub(super) static USE_STANDALONE: Cell<StandaloneLevel> = const { Cell::new(StandaloneLevel::FallbackOnly) };
     }
 
     fn standalone_bridge() -> Bridge<'static> {
diff --git a/library/proc_macro/src/bridge/standalone.rs b/library/proc_macro/src/bridge/standalone.rs
@@ -3,10 +3,10 @@
 use std::cell::RefCell;
 use std::ops::{Bound, Range};
 
-use crate::Delimiter;
+use crate::{Delimiter, LEGAL_PUNCT_CHARS};
 use crate::bridge::client::Symbol;
 use crate::bridge::fxhash::FxHashMap;
-use crate::bridge::{Diagnostic, ExpnGlobals, LitKind, Literal, TokenTree, server};
+use crate::bridge::{server, DelimSpan, Diagnostic, ExpnGlobals, Group, LitKind, Literal, Punct, TokenTree};
 
 pub struct NoRustc;
 
@@ -130,7 +130,22 @@ impl server::FreeFunctions for NoRustc {
     fn track_path(&mut self, _path: &str) {}
 
     fn literal_from_str(&mut self, s: &str) -> Result<Literal<Self::Span, Self::Symbol>, ()> {
-        todo!()
+        let mut chars = s.chars();
+        let Some(first) = chars.next() else {
+            return Err(());
+        };
+        br"";
+        cr"";
+
+        match first {
+            'b' => todo!(),
+            'c' => todo!(),
+            'r' => todo!(),
+            '0'..='9' | '-' => todo!(),
+            '\'' => todo!(),
+            '"' => todo!(),
+            _ => Err(())
+        }
     }
 
     fn emit_diagnostic(&mut self, diagnostic: Diagnostic<Self::Span>) {
@@ -148,10 +163,53 @@ impl server::TokenStream for NoRustc {
     }
 
     fn from_str(&mut self, src: &str) -> Self::TokenStream {
-        todo!()
+        /// Returns the delimiter, and whether it is the opening form.
+        fn char_to_delim(c: char) -> Option<(Delimiter, bool)> {
+            Some(match c {
+                '(' => (Delimiter::Parenthesis, true),
+                ')' => (Delimiter::Parenthesis, false),
+                '{' => (Delimiter::Brace, true),
+                '}' => (Delimiter::Brace, false),
+                '[' => (Delimiter::Bracket, true),
+                ']' => (Delimiter::Bracket, false),
+                _ => return None,
+            })
+        }
+
+        let mut unfinished_streams = vec![TokenStream::new()];
+        let mut unclosed_delimiters = Vec::new();
+        let mut current_ident = String::new();
+        for c in src.chars() {
+            if let Some((delim, is_opening)) = char_to_delim(c) {
+                if is_opening {
+                    unclosed_delimiters.push(delim);
+                    unfinished_streams.push(TokenStream::new());
+                } else if unclosed_delimiters.pop() == Some(delim) {
+                    let group = TokenTree::<_, _, Symbol>::Group(Group {
+                        delimiter: delim,
+                        stream: unfinished_streams.pop(),
+                        span: DelimSpan::from_single(Span::DUMMY)
+                    });
+                    unfinished_streams.last_mut().unwrap().0.push(group);
+                } else {
+                    panic!("cannot parse string into token stream")
+                }
+            } else if LEGAL_PUNCT_CHARS.contains(&c) {
+                unfinished_streams.last_mut().unwrap().0.push(TokenTree::Punct(Punct {
+                    ch: c as u8,
+                    joint: false, // TODO
+                    span: Span::DUMMY,
+                }));
+            }
+            match c {
+                _ => todo!(),
+            }
+        }
+        unfinished_streams[0].clone()
     }
 
     fn to_string(&mut self, tokens: &Self::TokenStream) -> String {
+        /*
         /// Returns a string containing exactly `num` '#' characters.
         /// Uses a 256-character source string literal which is always safe to
         /// index with a `u8` index.
@@ -164,7 +222,7 @@ impl server::TokenStream for NoRustc {
             ";
             const _: () = assert!(HASHES.len() == 256);
             &HASHES[..num as usize]
-        }
+        }*/
 
         let mut s = String::new();
         let mut last = String::new();
@@ -200,13 +258,20 @@ impl server::TokenStream for NoRustc {
                     }
                 }
                 TokenTree::Literal(lit) => {
-                    let inner = if let Some(suffix) = lit.suffix {
+                    let respanned = Literal {
+                        kind: lit.kind,
+                        symbol: lit.symbol,
+                        suffix: lit.suffix,
+                        span: super::client::Span::dummy(),
+                    };
+                    crate::Literal(respanned).to_string()
+                    /*let inner = if let Some(suffix) = lit.suffix {
                         format!("{}{suffix}", lit.symbol)
                     } else {
                         lit.symbol.to_string()
                     };
                     match lit.kind {
-                        LitKind::Byte => todo!(),
+                        LitKind::Byte => format!("b'{inner}'"),
                         LitKind::ByteStr => format!("b\"{inner}\""),
                         LitKind::ByteStrRaw(raw) => {
                             format!("br{0}\"{inner}\"{0}", get_hashes_str(raw))
@@ -220,7 +285,7 @@ impl server::TokenStream for NoRustc {
                         LitKind::Float | LitKind::Integer => inner,
                         LitKind::Str => format!("\"{inner}\""),
                         LitKind::StrRaw(raw) => format!("r{0}\"{inner}\"{0}", get_hashes_str(raw)),
-                    }
+                    }*/
                 }
                 TokenTree::Punct(punct) => {
                     let c = punct.ch as char;
@@ -231,7 +296,7 @@ impl server::TokenStream for NoRustc {
                 }
             };
 
-            const NON_SEPARATABLE_TOKENS: &[(char, char)] = &[(':', ':'), ('-', '>')];
+            const NON_SEPARATABLE_TOKENS: &[(char, char)] = &[(':', ':'), ('-', '>'), ('=', '>')];
 
             for (first, second) in NON_SEPARATABLE_TOKENS {
                 if second_last == first.to_string() && last == second.to_string() && new_part != ":"
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
@@ -969,6 +969,11 @@ pub enum Spacing {
     Alone,
 }
 
+pub(crate) const LEGAL_PUNCT_CHARS: &[char] = &[
+    '=', '<', '>', '!', '~', '+', '-', '*', '/', '%', '^', '&', '|', '@', '.', ',', ';',
+    ':', '#', '$', '?', '\'',
+];
+
 impl Punct {
     /// Creates a new `Punct` from the given character and spacing.
     /// The `ch` argument must be a valid punctuation character permitted by the language,
@@ -978,11 +983,7 @@ impl Punct {
     /// which can be further configured with the `set_span` method below.
     #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
     pub fn new(ch: char, spacing: Spacing) -> Punct {
-        const LEGAL_CHARS: &[char] = &[
-            '=', '<', '>', '!', '~', '+', '-', '*', '/', '%', '^', '&', '|', '@', '.', ',', ';',
-            ':', '#', '$', '?', '\'',
-        ];
-        if !LEGAL_CHARS.contains(&ch) {
+        if !LEGAL_PUNCT_CHARS.contains(&ch) {
             panic!("unsupported character `{:?}`", ch);
         }
         Punct(bridge::Punct {
@@ -1178,7 +1179,7 @@ macro_rules! unsuffixed_int_literals {
         /// specified on this token, meaning that invocations like
         /// `Literal::i8_unsuffixed(1)` are equivalent to
         /// `Literal::u32_unsuffixed(1)`.
-        /// Literals created from negative numbers might not survive rountrips through
+        /// Literals created from negative numbers might not survive roundtrips through
         /// `TokenStream` or strings and may be broken into two tokens (`-` and positive literal).
         ///
         /// Literals created through this method have the `Span::call_site()`
@@ -1241,7 +1242,7 @@ impl Literal {
     /// This constructor is similar to those like `Literal::i8_unsuffixed` where
     /// the float's value is emitted directly into the token but no suffix is
     /// used, so it may be inferred to be a `f64` later in the compiler.
-    /// Literals created from negative numbers might not survive rountrips through
+    /// Literals created from negative numbers might not survive roundtrips through
     /// `TokenStream` or strings and may be broken into two tokens (`-` and positive literal).
     ///
     /// # Panics
@@ -1266,7 +1267,7 @@ impl Literal {
     /// specified is the preceding part of the token and `f32` is the suffix of
     /// the token. This token will always be inferred to be an `f32` in the
     /// compiler.
-    /// Literals created from negative numbers might not survive rountrips through
+    /// Literals created from negative numbers might not survive roundtrips through
     /// `TokenStream` or strings and may be broken into two tokens (`-` and positive literal).
     ///
     /// # Panics
@@ -1286,7 +1287,7 @@ impl Literal {
     /// This constructor is similar to those like `Literal::i8_unsuffixed` where
     /// the float's value is emitted directly into the token but no suffix is
     /// used, so it may be inferred to be a `f64` later in the compiler.
-    /// Literals created from negative numbers might not survive rountrips through
+    /// Literals created from negative numbers might not survive roundtrips through
     /// `TokenStream` or strings and may be broken into two tokens (`-` and positive literal).
     ///
     /// # Panics
@@ -1311,7 +1312,7 @@ impl Literal {
     /// specified is the preceding part of the token and `f64` is the suffix of
     /// the token. This token will always be inferred to be an `f64` in the
     /// compiler.
-    /// Literals created from negative numbers might not survive rountrips through
+    /// Literals created from negative numbers might not survive roundtrips through
     /// `TokenStream` or strings and may be broken into two tokens (`-` and positive literal).
     ///
     /// # Panics
