Struct TokenAccumulator 

pub struct TokenAccumulator(Result<TokenStream, Error>);

Accumulates tokens, or errors

We collect all the errors, and if we get an error, don’t write anything out. This is because compile_error! (from into_compile_error) only works in certain places in Rust syntax (!)

Tuple Fields

0: Result<TokenStream, Error>

Implementations

impl TokenAccumulator

pub fn new() -> Self

pub fn with_tokens<R>( &mut self, f: impl FnOnce(&mut TokenStream) -> R, ) -> Option<R>

pub fn append(&mut self, t: impl ToTokens)

pub fn tokens(self) -> Result<TokenStream>

pub fn append_maybe_punct_composable( &mut self, val: &(impl ToTokens + ToTokensPunctComposable), composable: bool, )

Appends val, via ToTokensPunctComposable or ToTokens

Trait Implementations

impl Debug for TokenAccumulator

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

Formats the value using the given formatter.

impl Default for TokenAccumulator

fn default() -> Self

Returns the “default value” for a type.

impl Expand<TokenAccumulator> for TemplateElement<TokenAccumulator>

fn expand<'c>( &self, ctx: GeneralContext<'c>, out: &mut TokenAccumulator, ) -> Result<()>

impl ExpansionOutput for TokenAccumulator

fn append_identfrag_toks<I: IdentFrag>( &mut self, ident: &I, ) -> Result<(), I::BadIdent>

An identifier (or fragment of one)

fn append_idpath<A, B, I>( &mut self, _te_span: Span, pre: A, ident: &I, post: B, grouping: Grouping, ) -> Result<(), I::BadIdent>

where A: FnOnce(&mut TokenAccumulator), B: FnOnce(&mut TokenAccumulator), I: IdentFrag,

Append a Rust path (scoped identifier, perhaps with generics)

fn append_syn_litstr(&mut self, lit: &LitStr)

Append a syn::LitStr

fn append_syn_type_inner( &mut self, _te_span: Span, ty: Type, grouping: Grouping, )

Append a syn::Type, which has been grouping-normalised

fn append_tokens_with( &mut self, (_not_in_paste, _not_in_concat): &((), ()), f: impl FnOnce(&mut TokenAccumulator) -> Result<()>, ) -> Result<()>

Append using a function which generates tokens

fn append_bool_only(&mut self, bool_only: &Self::BoolOnly) -> !

“Append” a substitution which can only be used within a boolean

fn record_error(&mut self, err: Error)

Note that an error occurred

fn new_with_span(_kw_span: Span) -> Self

Make a new empty expansion output, introduced at kw_span

fn ignore_impl(self) -> Result<()>

Implement the core of the ignore keyword

fn dbg_expand<'c>( &mut self, _kw_span: Span, ctx: GeneralContext<'c>, msg: &mut String, content: &Template<TokenAccumulator>, ) -> Result

Implement the dbg keyword

fn append_syn_type(&mut self, te_span: Span, v: Type, grouping: Grouping)

Append a syn::Type

fn write_error<S: Spanned, M: Display>(&mut self, span: &S, message: M)

Convenience method for noting an error with span and message

fn append_tokens( &mut self, allow_tokens: &(<Self as SubstParseContext>::NotInPaste, <Self as SubstParseContext>::NotInConcat), tokens: impl ToTokens, ) -> Result<()>

Convenience method for writing a ToTokens

fn default_subst_meta_as(kw: Span) -> Result<SubstAs<Self>>

impl SubstParseContext for TokenAccumulator

type NotInPaste = ()

Uninhabited iff this lexical context is within ${paste }

type NotInConcat = ()

Uninhabited iff this lexical context is within ${concat }

type NotInBool = ()

Uninhabited iff this lexical context is within a condition.

type DbgContent = Template<TokenAccumulator>

Content of the dbg keyword

type BoolOnly = Void

Uninhabited unless this lexical context is within a condition.

type ConcatOnly = Void

Uninhabited unless this lexical context is within ${concat }

type SpecialParseContext = ()

For communicating through parse_special

fn not_in_paste(_: &impl Spanned) -> Result<()>

fn not_in_concat(_: &impl Spanned) -> Result<()>

fn not_in_bool(_: &impl Spanned) -> Result<()>

const IS_BOOL: bool = false

Whether this is a boolean context

fn bool_only(span: &impl Spanned) -> Result<Self::BoolOnly>

fn concat_only(span: &impl Spanned) -> Result<Self::ConcatOnly>

fn meta_recog_usage(m: &SubstMeta<Self>) -> UsageInfo<IsUsed>

When we find a fmeta etc. in this context, does it allow a value?

fn parse_maybe_within_parens<T>( input: ParseStream<'_>, f: impl FnOnce(ParseStream<'_>) -> Result<T>, ) -> Result<T>

Parse using f, within parens in boolean context, not otherwise

fn parse_maybe_comma(input: ParseStream<'_>) -> Result<()>

Parse maybe a comma (comma in boolean contegxt, not otherwise)

fn missing_keyword_arguments(kw_span: Span) -> Result<Void>

Return an error suitable for reporting missing arguments