Struct `TokenStream`

pub struct TokenStream(pub(crate) Option<TokenStream>);

The main type provided by this crate, representing an abstract stream of tokens, or, more specifically, a sequence of token trees. The type provides interfaces for iterating over those token trees and, conversely, collecting a number of token trees into one stream.

This is both the input and output of #[proc_macro], #[proc_macro_attribute] and #[proc_macro_derive] definitions.

Fields

0: Option<TokenStream>

Implementations

`impl TokenStream`

fn new() -> TokenStream

Returns an empty TokenStream containing no token trees.

fn is_empty(&self) -> bool

Checks if this TokenStream is empty.

fn expand_expr(&self) -> Result<TokenStream, ExpandError>

Parses this TokenStream as an expression and attempts to expand any macros within it. Returns the expanded TokenStream.

Currently only expressions expanding to literals will succeed, although this may be relaxed in the future.

NOTE: In error conditions, expand_expr may leave macros unexpanded, report an error, failing compilation, and/or return an Err(..). The specific behavior for any error condition, and what conditions are considered errors, is unspecified and may change in the future.

Trait Implementations

`impl !Send for TokenStream`

`impl !Sync for TokenStream`

`impl Clone for TokenStream`

fn clone(&self) -> TokenStream

`impl Debug for TokenStream`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl Decode<'_, '_, ()> for TokenStream`

fn decode(r: &mut &[u8], s: &mut ()) -> Self

`impl Default for TokenStream`

fn default() -> Self

`impl Display for TokenStream`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl Encode<()> for TokenStream`

fn encode(self, w: &mut Buffer, s: &mut ())

`impl Extend<Group> for TokenStream`

fn extend<I: IntoIterator<Item = Group>>(&mut self, iter: I)

`impl Extend<Ident> for TokenStream`

fn extend<I: IntoIterator<Item = Ident>>(&mut self, iter: I)

`impl Extend<Literal> for TokenStream`

fn extend<I: IntoIterator<Item = Literal>>(&mut self, iter: I)

`impl Extend<Punct> for TokenStream`

fn extend<I: IntoIterator<Item = Punct>>(&mut self, iter: I)

`impl Extend<TokenStream> for TokenStream`

fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I)

`impl Extend<TokenTree> for TokenStream`

fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, trees: I)

`impl From<TokenTree> for TokenStream`

fn from(tree: TokenTree) -> TokenStream

`impl FromIterator<TokenStream> for TokenStream`

fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self

`impl FromIterator<TokenTree> for TokenStream`

fn from_iter<I: IntoIterator<Item = TokenTree>>(trees: I) -> Self

`impl FromStr for TokenStream`

type Err = LexError;
fn from_str(src: &str) -> Result<TokenStream, LexError>

`impl IntoIterator for TokenStream`

type Item = TokenTree;
type IntoIter = IntoIter;
fn into_iter(self) -> IntoIter

`impl ToTokens for TokenStream`

fn to_tokens(&self, tokens: &mut TokenStream)
fn into_token_stream(self) -> TokenStream

Auto Trait Implementations

`impl Freeze for TokenStream`

`impl RefUnwindSafe for TokenStream`

`impl Unpin for TokenStream`

`impl UnsafeUnpin for TokenStream`

`impl UnwindSafe for TokenStream`

Blanket Implementations

`impl<T> Any for TokenStream where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for TokenStream where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for TokenStream where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for TokenStream where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for TokenStream`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> RepToTokensExt for TokenStream where T: ToTokens + ?Sized,`

`impl<T> SizeHint for TokenStream where T: ?Sized,`

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

`impl<T> SizedTypeProperties for TokenStream`

`impl<T> ToOwned for TokenStream where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T> ToString for TokenStream where T: Display + ?Sized,`

fn to_string(&self) -> String

`impl<T, U> Into<U> for TokenStream where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for TokenStream where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto<U> for TokenStream where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>