Trait RefWithSpan 

pub trait RefWithSpan:
    WithSpan
    + ToTokens
    + RefWithSpan {
    type RefWithDefaultSpan<'a, S: Span>: ToTokens + Copy + RefWithSpan
       where Self: 'a;
    type RefWithReplacedSpan<'a, S: Span>: ToTokens + Copy + RefWithSpan
       where Self: 'a;

    // Required methods
    fn ref_with_default_span<S: Span>(
        &self,
        span: S,
    ) -> Self::RefWithDefaultSpan<'_, S>;
    fn ref_with_replaced_span<S: Span>(
        &self,
        span: S,
    ) -> Self::RefWithReplacedSpan<'_, S>;
}

To tokens with new span.

This trait is sealed and all methods are provided.

Required Associated Types

type RefWithDefaultSpan<'a, S: Span>: ToTokens + Copy + RefWithSpan where Self: 'a

type RefWithReplacedSpan<'a, S: Span>: ToTokens + Copy + RefWithSpan where Self: 'a

Required Methods

fn ref_with_default_span<S: Span>( &self, span: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl RefWithSpan for TT

Available on crate feature proc-macro and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a TokenTree where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, TokenTree, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro2 and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a TokenTree where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, TokenTree, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Group where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Group, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Ident where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Ident, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Literal where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Literal, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Punct where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Punct, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TokenStream

Available on crate feature proc-macro and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a TokenStream where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, TokenStream, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro2 and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Group where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Group, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro2 and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Ident where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Ident, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro2 and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Literal where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Literal, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TT

Available on crate feature proc-macro2 and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a Punct where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, Punct, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl RefWithSpan for TokenStream

Available on crate feature proc-macro2 and (crate features proc-macro or proc-macro2) only.

type RefWithDefaultSpan<'a, S: Span> = &'a TokenStream where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ReplaceSpanOfRef<'a, TokenStream, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, _: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl<'this, T: ?Sized + RefWithSpan> RefWithSpan for &'this T

type RefWithDefaultSpan<'a, S: Span> = <T as RefWithSpan>::RefWithDefaultSpan<'this, S> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = <T as RefWithSpan>::RefWithReplacedSpan<'this, S> where Self: 'a

fn ref_with_default_span<S: Span>( &self, span: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

impl<T: RefWithSpan> RefWithSpan for Option<T>

type RefWithDefaultSpan<'a, S: Span> = Option<<T as RefWithSpan>::RefWithDefaultSpan<'a, S>> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = Option<<T as RefWithSpan>::RefWithReplacedSpan<'a, S>> where Self: 'a

fn ref_with_default_span<S: Span>( &self, span: S, ) -> Self::RefWithDefaultSpan<'_, S>

fn ref_with_replaced_span<S: Span>( &self, span: S, ) -> Self::RefWithReplacedSpan<'_, S>

Implementors

impl RefWithSpan for Never

type RefWithDefaultSpan<'a, S: Span> = Never where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = Never where Self: 'a

impl RefWithSpan for Empty

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Empty as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Empty as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<'a, SO: MaybeSpan> RefWithSpan for Ident<'a, SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Ident<'a, SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Ident<'a, SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<'a, SO: MaybeSpan> RefWithSpan for Lifetime<'a, SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Lifetime<'a, SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Lifetime<'a, SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<'a, SO: MaybeSpan> RefWithSpan for Literal<'a, SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Literal<'a, SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Literal<'a, SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<A: RefWithSpan, B: RefWithSpan> RefWithSpan for Either<A, B>

type RefWithDefaultSpan<'a, S: Span> = Either<<A as RefWithSpan>::RefWithDefaultSpan<'a, S>, <B as RefWithSpan>::RefWithDefaultSpan<'a, S>> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = Either<<A as RefWithSpan>::RefWithReplacedSpan<'a, S>, <B as RefWithSpan>::RefWithReplacedSpan<'a, S>> where Self: 'a

impl<A: RefWithSpan, B: RefWithSpan> RefWithSpan for Concat<A, B>

type RefWithDefaultSpan<'a, S: Span> = ConcatWithDefaultSpan<&'a A, &'a B, S> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ConcatWithReplacedSpan<&'a A, &'a B, S> where Self: 'a

impl<A: RefWithSpan, B: RefWithSpan, SO: Span> RefWithSpan for ConcatWithDefaultSpan<A, B, SO>

type RefWithDefaultSpan<'a, S: Span> = &'a ConcatWithDefaultSpan<A, B, SO> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ConcatWithReplacedSpan<&'a A, &'a B, S> where Self: 'a

impl<A: RefWithSpan, B: RefWithSpan, SO: Span> RefWithSpan for ConcatWithReplacedSpan<A, B, SO>

type RefWithDefaultSpan<'a, S: Span> = &'a ConcatWithReplacedSpan<A, B, SO> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = ConcatWithReplacedSpan<&'a A, &'a B, S> where Self: 'a

impl<I: IntoIterator<Item: IntoTokens + WithSpan> + Clone> RefWithSpan for IterTokens<I>

type RefWithDefaultSpan<'a, S: Span> = IterTokensWithDefaultSpan<CloneIntoIter<'a, I>, S> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = IterTokensWithReplacedSpan<CloneIntoIter<'a, I>, S> where Self: 'a

impl<I: IntoIterator<Item: IntoTokens + WithSpan> + Clone, SO: Span> RefWithSpan for IterTokensWithDefaultSpan<I, SO>

type RefWithDefaultSpan<'a, S: Span> = &'a IterTokensWithDefaultSpan<I, SO> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = IterTokensWithReplacedSpan<CloneIntoIter<'a, I>, S> where Self: 'a

impl<I: IntoIterator<Item: IntoTokens + WithSpan> + Clone, SO: Span> RefWithSpan for IterTokensWithReplacedSpan<I, SO>

type RefWithDefaultSpan<'a, S: Span> = &'a IterTokensWithReplacedSpan<I, SO> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = IterTokensWithReplacedSpan<CloneIntoIter<'a, I>, S> where Self: 'a

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Add<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Add<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Add<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::And<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <And<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <And<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::At<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <At<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <At<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Bang<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Bang<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Bang<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Caret<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Caret<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Caret<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Colon<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Colon<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Colon<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Comma<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Comma<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Comma<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Div<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Div<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Div<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Dollar<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Dollar<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Dollar<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Dot<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Dot<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Dot<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Eq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Eq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Eq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Gt<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Gt<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Gt<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Lt<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Lt<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Lt<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Or<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Or<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Or<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Pound<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Pound<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Pound<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Question<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Question<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Question<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Rem<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Rem<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Rem<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Semi<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Semi<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Semi<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Star<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Star<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Star<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Sub<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Sub<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Sub<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::punct::Tilde<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Tilde<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Tilde<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::AddEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <AddEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <AddEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::AndAnd<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <AndAnd<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <AndAnd<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::AndEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <AndEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <AndEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::CaretEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <CaretEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <CaretEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Colon2<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Colon2<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Colon2<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::DivEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <DivEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <DivEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Dot2<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Dot2<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Dot2<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Dot3<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Dot3<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Dot3<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::DotDotEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <DotDotEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <DotDotEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::EqEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <EqEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <EqEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::FatArrow<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <FatArrow<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <FatArrow<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Ge<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Ge<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Ge<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::LArrow<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <LArrow<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <LArrow<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Le<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Le<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Le<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::MulEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <MulEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <MulEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Ne<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Ne<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Ne<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::OrEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <OrEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <OrEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::OrOr<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <OrOr<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <OrOr<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::RArrow<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <RArrow<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <RArrow<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::RemEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <RemEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <RemEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Shl<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Shl<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Shl<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::ShlEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <ShlEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <ShlEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::Shr<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <Shr<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <Shr<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::ShrEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <ShrEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <ShrEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<SO: MaybeSpan> RefWithSpan for typed_quote::tokens::puncts::SubEq<SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <SubEq<SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <SubEq<SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<T: HasConstIdent + ?Sized, SO: MaybeSpan> RefWithSpan for ConstIdent<T, SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <ConstIdent<T, SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <ConstIdent<T, SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<T: HasConstLifetime + ?Sized, SO: MaybeSpan> RefWithSpan for ConstLifetime<T, SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <ConstLifetime<T, SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <ConstLifetime<T, SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<T: HasConstLiteral + ?Sized, SO: MaybeSpan> RefWithSpan for ConstLiteral<T, SO>

type RefWithDefaultSpan<'ref_with_span, S: Span> = <ConstLiteral<T, SO> as WithSpan>::WithDefaultSpan<S> where Self: 'ref_with_span

type RefWithReplacedSpan<'ref_with_span, S: Span> = <ConstLiteral<T, SO> as WithSpan>::WithReplacedSpan<S> where Self: 'ref_with_span

impl<T: IntoTokens + RefWithSpan, SO: MaybeSpan> RefWithSpan for typed_quote::tokens::Brace<T, SO>

type RefWithDefaultSpan<'a, S: Span> = Brace<<T as RefWithSpan>::RefWithDefaultSpan<'a, S>, <SO as MaybeSpan>::WithDefaultSpan<S>> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = Brace<<T as RefWithSpan>::RefWithReplacedSpan<'a, S>, <SO as MaybeSpan>::WithReplacedSpan<S>> where Self: 'a

impl<T: IntoTokens + RefWithSpan, SO: MaybeSpan> RefWithSpan for typed_quote::tokens::Bracket<T, SO>

type RefWithDefaultSpan<'a, S: Span> = Bracket<<T as RefWithSpan>::RefWithDefaultSpan<'a, S>, <SO as MaybeSpan>::WithDefaultSpan<S>> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = Bracket<<T as RefWithSpan>::RefWithReplacedSpan<'a, S>, <SO as MaybeSpan>::WithReplacedSpan<S>> where Self: 'a

impl<T: IntoTokens + RefWithSpan, SO: MaybeSpan> RefWithSpan for typed_quote::tokens::Parenthesis<T, SO>

type RefWithDefaultSpan<'a, S: Span> = Parenthesis<<T as RefWithSpan>::RefWithDefaultSpan<'a, S>, <SO as MaybeSpan>::WithDefaultSpan<S>> where Self: 'a

type RefWithReplacedSpan<'a, S: Span> = Parenthesis<<T as RefWithSpan>::RefWithReplacedSpan<'a, S>, <SO as MaybeSpan>::WithReplacedSpan<S>> where Self: 'a