#![feature(staged_api)]
#![feature(allow_internal_unstable)]
#![feature(decl_macro)]
+#![feature(local_key_cell_methods)]
+#![feature(maybe_uninit_write_slice)]
#![feature(negative_impls)]
+#![feature(new_uninit)]
#![feature(restricted_std)]
#![feature(rustc_attrs)]
#![feature(min_specialization)]
+#![feature(strict_provenance)]
#![recursion_limit = "256"]
#[unstable(feature = "proc_macro_internals", issue = "27812")]
/// inside of a procedural macro, false if invoked from any other binary.
#[stable(feature = "proc_macro_is_available", since = "1.57.0")]
pub fn is_available() -> bool {
- bridge::Bridge::is_available()
+ bridge::client::is_available()
}
/// The main type provided by this crate, representing an abstract stream of
fn tree_to_bridge_tree(
tree: TokenTree,
) -> bridge::TokenTree<
- bridge::client::Group,
- bridge::client::Punct,
- bridge::client::Ident,
+ bridge::client::TokenStream,
+ bridge::client::Span,
+ bridge::client::Symbol,
bridge::client::Literal,
> {
match tree {
/// Non-generic helper for implementing `FromIterator<TokenTree>` and
/// `Extend<TokenTree>` with less monomorphization in calling crates.
-struct ExtendStreamWithTreesHelper {
+struct ConcatTreesHelper {
trees: Vec<
bridge::TokenTree<
- bridge::client::Group,
- bridge::client::Punct,
- bridge::client::Ident,
+ bridge::client::TokenStream,
+ bridge::client::Span,
+ bridge::client::Symbol,
bridge::client::Literal,
>,
>,
}
-impl ExtendStreamWithTreesHelper {
+impl ConcatTreesHelper {
fn new(capacity: usize) -> Self {
- ExtendStreamWithTreesHelper { trees: Vec::with_capacity(capacity) }
+ ConcatTreesHelper { trees: Vec::with_capacity(capacity) }
}
fn push(&mut self, tree: TokenTree) {
}
}
- fn extend(self, stream: &mut TokenStream) {
+ fn append_to(self, stream: &mut TokenStream) {
if self.trees.is_empty() {
return;
}
/// Non-generic helper for implementing `FromIterator<TokenStream>` and
/// `Extend<TokenStream>` with less monomorphization in calling crates.
-struct ExtendStreamWithStreamsHelper {
+struct ConcatStreamsHelper {
streams: Vec<bridge::client::TokenStream>,
}
-impl ExtendStreamWithStreamsHelper {
+impl ConcatStreamsHelper {
fn new(capacity: usize) -> Self {
- ExtendStreamWithStreamsHelper { streams: Vec::with_capacity(capacity) }
+ ConcatStreamsHelper { streams: Vec::with_capacity(capacity) }
}
fn push(&mut self, stream: TokenStream) {
}
}
- fn extend(mut self, stream: &mut TokenStream) {
+ fn append_to(mut self, stream: &mut TokenStream) {
if self.streams.is_empty() {
return;
}
impl iter::FromIterator<TokenTree> for TokenStream {
fn from_iter<I: IntoIterator<Item = TokenTree>>(trees: I) -> Self {
let iter = trees.into_iter();
- let mut builder = ExtendStreamWithTreesHelper::new(iter.size_hint().0);
+ let mut builder = ConcatTreesHelper::new(iter.size_hint().0);
iter.for_each(|tree| builder.push(tree));
builder.build()
}
impl iter::FromIterator<TokenStream> for TokenStream {
fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
let iter = streams.into_iter();
- let mut builder = ExtendStreamWithStreamsHelper::new(iter.size_hint().0);
+ let mut builder = ConcatStreamsHelper::new(iter.size_hint().0);
iter.for_each(|stream| builder.push(stream));
builder.build()
}
impl Extend<TokenTree> for TokenStream {
fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, trees: I) {
let iter = trees.into_iter();
- let mut builder = ExtendStreamWithTreesHelper::new(iter.size_hint().0);
+ let mut builder = ConcatTreesHelper::new(iter.size_hint().0);
iter.for_each(|tree| builder.push(tree));
- builder.extend(self);
+ builder.append_to(self);
}
}
impl Extend<TokenStream> for TokenStream {
fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
let iter = streams.into_iter();
- let mut builder = ExtendStreamWithStreamsHelper::new(iter.size_hint().0);
+ let mut builder = ConcatStreamsHelper::new(iter.size_hint().0);
iter.for_each(|stream| builder.push(stream));
- builder.extend(self);
+ builder.append_to(self);
}
}
pub struct IntoIter(
std::vec::IntoIter<
bridge::TokenTree<
- bridge::client::Group,
- bridge::client::Punct,
- bridge::client::Ident,
+ bridge::client::TokenStream,
+ bridge::client::Span,
+ bridge::client::Symbol,
bridge::client::Literal,
>,
>,
type IntoIter = IntoIter;
fn into_iter(self) -> IntoIter {
- IntoIter(self.0.map(|v| v.into_iter()).unwrap_or_default().into_iter())
+ IntoIter(self.0.map(|v| v.into_trees()).unwrap_or_default().into_iter())
}
}
}
/// A `Group` internally contains a `TokenStream` which is surrounded by `Delimiter`s.
#[derive(Clone)]
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
-pub struct Group(bridge::client::Group);
+pub struct Group(bridge::Group<bridge::client::TokenStream, bridge::client::Span>);
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
impl !Send for Group {}
/// method below.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
- Group(bridge::client::Group::new(delimiter, stream.0))
+ Group(bridge::Group {
+ delimiter,
+ stream: stream.0,
+ span: bridge::DelimSpan::from_single(Span::call_site().0),
+ })
}
/// Returns the delimiter of this `Group`
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn delimiter(&self) -> Delimiter {
- self.0.delimiter()
+ self.0.delimiter
}
/// Returns the `TokenStream` of tokens that are delimited in this `Group`.
/// returned above.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn stream(&self) -> TokenStream {
- TokenStream(Some(self.0.stream()))
+ TokenStream(self.0.stream.clone())
}
/// Returns the span for the delimiters of this token stream, spanning the
/// ```
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn span(&self) -> Span {
- Span(self.0.span())
+ Span(self.0.span.entire)
}
/// Returns the span pointing to the opening delimiter of this group.
/// ```
#[stable(feature = "proc_macro_group_span", since = "1.55.0")]
pub fn span_open(&self) -> Span {
- Span(self.0.span_open())
+ Span(self.0.span.open)
}
/// Returns the span pointing to the closing delimiter of this group.
/// ```
#[stable(feature = "proc_macro_group_span", since = "1.55.0")]
pub fn span_close(&self) -> Span {
- Span(self.0.span_close())
+ Span(self.0.span.close)
}
/// Configures the span for this `Group`'s delimiters, but not its internal
/// tokens at the level of the `Group`.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn set_span(&mut self, span: Span) {
- self.0.set_span(span.0);
+ self.0.span = bridge::DelimSpan::from_single(span.0);
}
}
/// forms of `Spacing` returned.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
#[derive(Clone)]
-pub struct Punct(bridge::client::Punct);
+pub struct Punct(bridge::Punct<bridge::client::Span>);
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
impl !Send for 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 {
- Punct(bridge::client::Punct::new(ch, spacing))
+ const LEGAL_CHARS: &[char] = &[
+ '=', '<', '>', '!', '~', '+', '-', '*', '/', '%', '^', '&', '|', '@', '.', ',', ';',
+ ':', '#', '$', '?', '\'',
+ ];
+ if !LEGAL_CHARS.contains(&ch) {
+ panic!("unsupported character `{:?}`", ch);
+ }
+ Punct(bridge::Punct {
+ ch: ch as u8,
+ joint: spacing == Spacing::Joint,
+ span: Span::call_site().0,
+ })
}
/// Returns the value of this punctuation character as `char`.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn as_char(&self) -> char {
- self.0.as_char()
+ self.0.ch as char
}
/// Returns the spacing of this punctuation character, indicating whether it's immediately
/// (`Alone`) so the operator has certainly ended.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn spacing(&self) -> Spacing {
- self.0.spacing()
+ if self.0.joint { Spacing::Joint } else { Spacing::Alone }
}
/// Returns the span for this punctuation character.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn span(&self) -> Span {
- Span(self.0.span())
+ Span(self.0.span)
}
/// Configure the span for this punctuation character.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn set_span(&mut self, span: Span) {
- self.0 = self.0.with_span(span.0);
+ self.0.span = span.0;
}
}
-// N.B., the bridge only provides `to_string`, implement `fmt::Display`
-// based on it (the reverse of the usual relationship between the two).
-#[stable(feature = "proc_macro_lib", since = "1.15.0")]
+#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
impl ToString for Punct {
fn to_string(&self) -> String {
- TokenStream::from(TokenTree::from(self.clone())).to_string()
+ self.as_char().to_string()
}
}
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
impl fmt::Display for Punct {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.write_str(&self.to_string())
+ write!(f, "{}", self.as_char())
}
}
/// An identifier (`ident`).
#[derive(Clone)]
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
-pub struct Ident(bridge::client::Ident);
+pub struct Ident(bridge::Ident<bridge::client::Span, bridge::client::Symbol>);
impl Ident {
/// Creates a new `Ident` with the given `string` as well as the specified
/// tokens, requires a `Span` to be specified at construction.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn new(string: &str, span: Span) -> Ident {
- Ident(bridge::client::Ident::new(string, span.0, false))
+ Ident(bridge::Ident {
+ sym: bridge::client::Symbol::new_ident(string, false),
+ is_raw: false,
+ span: span.0,
+ })
}
/// Same as `Ident::new`, but creates a raw identifier (`r#ident`).
/// (e.g. `self`, `super`) are not supported, and will cause a panic.
#[stable(feature = "proc_macro_raw_ident", since = "1.47.0")]
pub fn new_raw(string: &str, span: Span) -> Ident {
- Ident(bridge::client::Ident::new(string, span.0, true))
+ Ident(bridge::Ident {
+ sym: bridge::client::Symbol::new_ident(string, true),
+ is_raw: true,
+ span: span.0,
+ })
}
/// Returns the span of this `Ident`, encompassing the entire string returned
- /// by [`to_string`](Self::to_string).
+ /// by [`to_string`](ToString::to_string).
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn span(&self) -> Span {
- Span(self.0.span())
+ Span(self.0.span)
}
/// Configures the span of this `Ident`, possibly changing its hygiene context.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn set_span(&mut self, span: Span) {
- self.0 = self.0.with_span(span.0);
+ self.0.span = span.0;
}
}
-// N.B., the bridge only provides `to_string`, implement `fmt::Display`
-// based on it (the reverse of the usual relationship between the two).
-#[stable(feature = "proc_macro_lib", since = "1.15.0")]
+/// Converts the identifier to a string that should be losslessly convertible
+/// back into the same identifier.
+#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
impl ToString for Ident {
fn to_string(&self) -> String {
- TokenStream::from(TokenTree::from(self.clone())).to_string()
+ self.0.sym.with(|sym| if self.0.is_raw { ["r#", sym].concat() } else { sym.to_owned() })
}
}
-/// Prints the identifier as a string that should be losslessly convertible
-/// back into the same identifier.
+/// Prints the identifier as a string that should be losslessly convertible back
+/// into the same identifier.
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
impl fmt::Display for Ident {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.write_str(&self.to_string())
+ if self.0.is_raw {
+ f.write_str("r#")?;
+ }
+ fmt::Display::fmt(&self.0.sym, f)
}
}