Skip to main content

WithSpan

Trait WithSpan

pub trait WithSpan: IntoTokens + WithSpan {
    type WithDefaultSpan<S: Span>: IntoTokens + WithSpan;
    type WithReplacedSpan<S: Span>: IntoTokens + WithSpan;

    // Required methods
    fn with_default_span<S: Span>(self, span: S) -> Self::WithDefaultSpan<S>;
    fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>;
}

Expand description

Into tokens with new span.

This trait is sealed and all methods are provided.

Required Associated Types§

type WithDefaultSpan<S: Span>: IntoTokens + WithSpan

type WithReplacedSpan<S: Span>: IntoTokens + WithSpan

Required Methods§

fn with_default_span<S: Span>(self, span: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<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 WithSpan for TT

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

type WithDefaultSpan<S: Span> = TokenTree

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<TokenTree>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = TokenTree

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<TokenTree>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Group

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Group>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Ident

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Ident>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Literal

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Literal>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Punct

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Punct>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TokenStream

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

type WithDefaultSpan<S: Span> = TokenStream

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<TokenStream>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Group

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Group>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Ident

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Ident>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Literal

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Literal>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TT

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

type WithDefaultSpan<S: Span> = Punct

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<Punct>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl WithSpan for TokenStream

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

type WithDefaultSpan<S: Span> = TokenStream

type WithReplacedSpan<S: Span> = <S as ReplaceSpanOf<TokenStream>>::ReplaceSpanOf

fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

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

type WithDefaultSpan<S: Span> = <T as RefWithSpan>::RefWithDefaultSpan<'a, S>

type WithReplacedSpan<S: Span> = <T as RefWithSpan>::RefWithReplacedSpan<'a, S>

fn with_default_span<S: Span>(self, span: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

impl<T: WithSpan> WithSpan for Option<T>

type WithDefaultSpan<S: Span> = Option<<T as WithSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Option<<T as WithSpan>::WithReplacedSpan<S>>

fn with_default_span<S: Span>(self, span: S) -> Self::WithDefaultSpan<S>

fn with_replaced_span<S: Span>(self, span: S) -> Self::WithReplacedSpan<S>

Implementors§

impl WithSpan for Never

type WithDefaultSpan<S: Span> = Never

type WithReplacedSpan<S: Span> = Never

impl WithSpan for Empty

type WithDefaultSpan<S: Span> = Empty

type WithReplacedSpan<S: Span> = Empty

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

type WithDefaultSpan<S: Span> = Ident<'a, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Ident<'a, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Lifetime<'a, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Lifetime<'a, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Literal<'a, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Literal<'a, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Either<<A as WithSpan>::WithDefaultSpan<S>, <B as WithSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Either<<A as WithSpan>::WithReplacedSpan<S>, <B as WithSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = ConcatWithDefaultSpan<A, B, S>

type WithReplacedSpan<S: Span> = ConcatWithReplacedSpan<A, B, S>

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

type WithDefaultSpan<S: Span> = ConcatWithDefaultSpan<A, B, SO>

type WithReplacedSpan<S: Span> = ConcatWithReplacedSpan<A, B, S>

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

type WithDefaultSpan<S: Span> = ConcatWithReplacedSpan<A, B, SO>

type WithReplacedSpan<S: Span> = ConcatWithReplacedSpan<A, B, S>

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

type WithDefaultSpan<S: Span> = IterTokensWithDefaultSpan<I, S>

type WithReplacedSpan<S: Span> = IterTokensWithReplacedSpan<I, S>

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

type WithDefaultSpan<S: Span> = IterTokensWithDefaultSpan<I, SO>

type WithReplacedSpan<S: Span> = IterTokensWithReplacedSpan<I, S>

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

type WithDefaultSpan<S: Span> = IterTokensWithReplacedSpan<I, SO>

type WithReplacedSpan<S: Span> = IterTokensWithReplacedSpan<I, S>

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

type WithDefaultSpan<S: Span> = Add<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Add<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = And<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = And<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = At<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = At<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Bang<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Bang<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Caret<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Caret<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Colon<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Colon<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Comma<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Comma<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Div<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Div<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Dollar<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Dollar<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Dot<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Dot<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Eq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Eq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Gt<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Gt<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Lt<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Lt<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Or<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Or<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Pound<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Pound<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Question<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Question<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Rem<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Rem<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Semi<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Semi<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Star<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Star<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Sub<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Sub<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Tilde<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Tilde<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = AddEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = AddEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = AndAnd<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = AndAnd<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = AndEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = AndEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = CaretEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = CaretEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Colon2<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Colon2<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = DivEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = DivEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Dot2<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Dot2<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Dot3<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Dot3<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = DotDotEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = DotDotEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = EqEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = EqEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = FatArrow<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = FatArrow<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Ge<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Ge<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = LArrow<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = LArrow<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Le<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Le<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = MulEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = MulEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Ne<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Ne<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = OrEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = OrEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = OrOr<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = OrOr<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = RArrow<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = RArrow<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = RemEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = RemEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Shl<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Shl<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = ShlEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = ShlEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Shr<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Shr<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = ShrEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = ShrEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = SubEq<<SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = SubEq<<SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = ConstIdent<T, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = ConstIdent<T, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = ConstLifetime<T, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = ConstLifetime<T, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = ConstLiteral<T, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = ConstLiteral<T, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Brace<<T as WithSpan>::WithDefaultSpan<S>, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Brace<<T as WithSpan>::WithReplacedSpan<S>, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Bracket<<T as WithSpan>::WithDefaultSpan<S>, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Bracket<<T as WithSpan>::WithReplacedSpan<S>, <SO as MaybeSpan>::WithReplacedSpan<S>>

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

type WithDefaultSpan<S: Span> = Parenthesis<<T as WithSpan>::WithDefaultSpan<S>, <SO as MaybeSpan>::WithDefaultSpan<S>>

type WithReplacedSpan<S: Span> = Parenthesis<<T as WithSpan>::WithReplacedSpan<S>, <SO as MaybeSpan>::WithReplacedSpan<S>>