Struct Items 

pub struct Items {
    span: Span,
    items: Vec<Item>,
    errors: Vec<Error>,
    atoms: Vec<AtomForReport>,
}

Accumulator for things to be pasted

Implements ExpansionOutput and SubstParseContext: i.e., it corresponds to the lexical context for a ${paste }, and collects the identifier fragments being pasted.

Fields

span: Span

Error reporting for bad identifiers, and also the output span

items: Vec<Item>

errors: Vec<Error>

atoms: Vec<AtomForReport>

Implementations

impl Items

pub fn new(span: Span) -> Self

impl Items

fn append_atom(&mut self, item: Item)

fn append_item_raw(&mut self, item: Item)

fn append_plain<V: Display>(&mut self, span: Span, v: V)

Append a plain entry from something Display

Like ExpansionOutput::append_display but doesn’t need Spanned

pub fn append_fixed_string(&mut self, text: &'static str)

pub fn assemble( self, out: &mut impl ExpansionOutput, change_case: Option<ChangeCase>, ) -> Result<()>

Combine the accumulated pieces and append them to out

Calls append_idpath if the content contained a nontrivial expansion or append_identfrag_toks otherwise.

fn assemble_inner( tspan: Span, items: Vec<Item>, change_case: Option<ChangeCase>, atoms: Vec<AtomForReport>, ) -> Result<AssemblyInstruction>

Combine the accumulated pieces and say what to do

Inner, non-monomorphised, function for Items::assemble.

Returns Right with values to pass to append_idpath or Left with the value to pass to append_identfrag_toks.

Trait Implementations

impl Debug for Items

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

Formats the value using the given formatter.

impl Expand<Items> for TemplateElement<Items>

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

impl ExpansionOutput for Items

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_compat): &(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 new_with_span(kw_span: Span) -> Self

Make a new empty expansion output, introduced at kw_span

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

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<Items>, ) -> 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

impl SubstParseContext for Items

type NotInPaste = Void

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 BoolOnly = Void

Uninhabited unless this lexical context is within a condition.

type ConcatOnly = Void

Uninhabited unless this lexical context is within ${concat }

type DbgContent = Template<Items>

Content of the dbg keyword

type SpecialParseContext = Option<AngleBrackets>

For communicating through parse_special

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

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

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

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