Struct Accumulator 

pub struct Accumulator {
    def_span: Span,
    out_span: Option<Span>,
    text: String,
    errors: ErrorAccumulator,
}

Accumulator for string concatenation ${concat }

Implements ExpansionOutput and SubstParseContext: i.e., it corresponds to the lexical context for a ${concat }, and collects the string to be output.

Fields

def_span: Span

out_span: Option<Span>

text: String

errors: ErrorAccumulator

Implementations

impl Accumulator

pub fn finish_literal(self) -> Result<LitStr>

pub fn finish_onto<O>(self, np: &O::NotInPaste, out: &mut O)

where O: ExpansionOutput,

fn append_display(&mut self, span: Span, plain: impl Display + Spanned)

fn append_type_like(&mut self, tokens: TokenStream)

Convert a type to a “nice” string

syn::Type as ToTokens produces a lot of Spacing::Alone which results in a lot of excessive whitespace.

We use an algorithm which prints something reasonably pretty which we also think is probably parseable unless there None-delimited groups (which we make visible).

Note that our documentation doesn’t promise parseability, just readability.

This algorithm does obviously produce parseable output if the input is just a single identifier token.

Rules

• We never put spaces next to any of <>:
• We don’t put a space after & or '
• We don’t put a space before ,
• We put spaces just inside { } iff nonempty
• We don’t put spaces just inside ( ) or [ ] (or « »)
• Otherwise, we put a space between each pair of TTs

Trait Implementations

impl Debug for Accumulator

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

Formats the value using the given formatter.

impl Expand<Accumulator> for TemplateElement<Accumulator>

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

impl ExpansionOutput for Accumulator

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(&mut self, te_span: Span, v: Type, grouping: Grouping)

Append a syn::Type

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

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

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

Implement the dbg keyword

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 append_tokens_with( &mut self, (_not_in_paste, not_in_concat): &((), Void), _: 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 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 Accumulator

type NotInPaste = ()

Uninhabited iff this lexical context is within ${paste }

type NotInConcat = Void

Uninhabited iff this lexical context is within ${concat }

type NotInBool = ()

Uninhabited iff this lexical context is within a condition.

type BoolOnly = Void

Uninhabited unless this lexical context is within a condition.

type ConcatOnly = ()

Uninhabited unless this lexical context is within ${concat }

type DbgContent = Template<Accumulator>

Content of the dbg keyword

type SpecialParseContext = ()

For communicating through parse_special

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

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

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

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

const IS_BOOL: bool = false

Whether this is a boolean context

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

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