use rc, take 1

Author: cyrgani

library/proc_macro/src/bridge/client.rs

@@ -2,6 +2,7 @@
 
 use std::cell::RefCell;
 use std::marker::PhantomData;
+use std::rc::Rc;
 use std::sync::atomic::AtomicU32;
 
 use super::*;
@@ -256,7 +257,9 @@ impl Client<crate::TokenStream, crate::TokenStream> {
         Client {
             handle_counters: &COUNTERS,
             run: super::selfless_reify::reify_to_extern_c_fn_hrt_bridge(move |bridge| {
-                run_client(bridge, |input| f(crate::TokenStream(input)).0)
+                run_client(bridge, |input| {
+                    Rc::unwrap_or_clone(f(crate::TokenStream(Rc::new(input))).0)
+                })
             }),
             _marker: PhantomData,
         }
@@ -271,7 +274,10 @@ impl Client<(crate::TokenStream, crate::TokenStream), crate::TokenStream> {
             handle_counters: &COUNTERS,
             run: super::selfless_reify::reify_to_extern_c_fn_hrt_bridge(move |bridge| {
                 run_client(bridge, |(input, input2)| {
-                    f(crate::TokenStream(input), crate::TokenStream(input2)).0
+                    Rc::unwrap_or_clone(
+                        f(crate::TokenStream(Rc::new(input)), crate::TokenStream(Rc::new(input2)))
+                            .0,
+                    )
                 })
             }),
             _marker: PhantomData,

library/proc_macro/src/bridge/rpc.rs

@@ -210,7 +210,18 @@ impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {
         vec
     }
 }
+/*
+impl<S, T: Encode<S>> Encode<S> for Rc<T> {
+    fn encode(self, w: &mut Buffer, s: &mut S) {
+        T::encode(Rc::clone(self), w, s);
+    }
+}
 
+impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Rc<T> {
+    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
+        Rc::new(T::decode(r, s))
+    }
+}*/
 /// Simplified version of panic payloads, ignoring
 /// types other than `&'static str` and `String`.
 pub enum PanicMessage {

library/proc_macro/src/lib.rs

@@ -47,6 +47,7 @@ use core::ops::BitOr;
 use std::ffi::CStr;
 use std::ops::{Range, RangeBounds};
 use std::path::PathBuf;
+use std::rc::Rc;
 use std::str::FromStr;
 use std::{error, fmt};
 
@@ -99,7 +100,7 @@ pub fn is_available() -> bool {
 #[cfg_attr(feature = "rustc-dep-of-std", rustc_diagnostic_item = "TokenStream")]
 #[stable(feature = "proc_macro_lib", since = "1.15.0")]
 #[derive(Clone)]
-pub struct TokenStream(Vec<bridge::TokenTree<bridge::client::Span, bridge::client::Symbol>>);
+pub struct TokenStream(Rc<Vec<bridge::TokenTree<bridge::client::Span, bridge::client::Symbol>>>);
 
 #[stable(feature = "proc_macro_lib", since = "1.15.0")]
 impl !Send for TokenStream {}
@@ -153,7 +154,7 @@ impl TokenStream {
     /// Returns an empty `TokenStream` containing no token trees.
     #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
     pub fn new() -> TokenStream {
-        TokenStream(Vec::new())
+        TokenStream(Rc::new(Vec::new()))
     }
 
     /// Checks if this `TokenStream` is empty.
@@ -175,7 +176,7 @@ impl TokenStream {
     #[unstable(feature = "proc_macro_expand", issue = "90765")]
     pub fn expand_expr(&self) -> Result<TokenStream, ExpandError> {
         match BridgeMethods::ts_expand_expr(stream_to_bridge_stream(self.clone())) {
-            Ok(stream) => Ok(TokenStream(stream.trees)),
+            Ok(stream) => Ok(TokenStream(Rc::new(stream.trees))),
             Err(_) => Err(ExpandError),
         }
     }
@@ -193,7 +194,7 @@ impl FromStr for TokenStream {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        Ok(TokenStream(BridgeMethods::ts_from_str(src).trees))
+        Ok(TokenStream(Rc::new(BridgeMethods::ts_from_str(src).trees)))
     }
 }
 
@@ -237,7 +238,7 @@ pub use quote::{HasIterator, RepInterp, ThereIsNoIteratorInRepetition, ext, quot
 fn stream_to_bridge_stream(
     stream: TokenStream,
 ) -> bridge::TokenStream<bridge::client::Span, bridge::client::Symbol> {
-    bridge::TokenStream { trees: stream.0 }
+    bridge::TokenStream { trees: stream.0.to_vec() }
 }
 
 fn tree_to_bridge_tree(
@@ -255,7 +256,7 @@ fn tree_to_bridge_tree(
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 impl From<TokenTree> for TokenStream {
     fn from(tree: TokenTree) -> TokenStream {
-        TokenStream(vec![tree_to_bridge_tree(tree)])
+        TokenStream(Rc::new(vec![tree_to_bridge_tree(tree)]))
     }
 }
 
@@ -275,14 +276,7 @@ impl ConcatTreesHelper {
     }
 
     fn build(self) -> TokenStream {
-        TokenStream(self.trees)
-    }
-
-    fn append_to(mut self, stream: &mut TokenStream) {
-        if self.trees.is_empty() {
-            return;
-        }
-        stream.0.append(&mut self.trees);
+        TokenStream(Rc::new(self.trees))
     }
 }
 
@@ -308,15 +302,6 @@ impl ConcatStreamsHelper {
         }
         stream
     }
-
-    fn append_to(self, stream: &mut TokenStream) {
-        if self.streams.is_empty() {
-            return;
-        }
-        for mut s in self.streams {
-            stream.0.append(&mut s.0);
-        }
-    }
 }
 
 /// Collects a number of token trees into a single stream.
@@ -348,7 +333,12 @@ impl Extend<TokenTree> for TokenStream {
         let iter = trees.into_iter();
         let mut builder = ConcatTreesHelper::new(iter.size_hint().0);
         iter.for_each(|tree| builder.push(tree));
-        builder.append_to(self);
+        if builder.trees.is_empty() {
+            return;
+        }
+        let mut old = (*self.0).clone();
+        old.append(&mut builder.trees);
+        self.0 = Rc::new(old);
     }
 }
 
@@ -358,7 +348,11 @@ impl Extend<TokenStream> for TokenStream {
         let iter = streams.into_iter();
         let mut builder = ConcatStreamsHelper::new(iter.size_hint().0);
         iter.for_each(|stream| builder.push(stream));
-        builder.append_to(self);
+        for s in builder.streams {
+            let mut old = (*self.0).clone();
+            old.append(&mut Rc::unwrap_or_clone(s.0));
+            self.0 = Rc::new(old);
+        }
     }
 }
 
@@ -380,6 +374,8 @@ extend_items!(Group Literal Punct Ident);
 /// Public implementation details for the `TokenStream` type, such as iterators.
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 pub mod token_stream {
+    use std::rc::Rc;
+
     use crate::{Group, Ident, Literal, Punct, TokenStream, TokenTree, bridge};
 
     /// An iterator over `TokenStream`'s `TokenTree`s.
@@ -419,7 +415,7 @@ pub mod token_stream {
         type IntoIter = IntoIter;
 
         fn into_iter(self) -> IntoIter {
-            IntoIter(self.0.into_iter())
+            IntoIter(Rc::unwrap_or_clone(self.0).into_iter())
         }
     }
 }
@@ -815,8 +811,8 @@ impl Group {
     #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
     pub fn stream(&self) -> TokenStream {
         match &self.0.stream {
-            Some(stream) => TokenStream(stream.trees.clone()),
-            None => TokenStream(vec![]),
+            Some(stream) => TokenStream(Rc::new(stream.trees.clone())),
+            None => TokenStream(Rc::new(vec![])),
         }
     }