Struct SpannableNode

pub struct SpannableNode<T: Parse> { /* private fields */ }

A node is anything that implements Parse. SpannableNode then, is a wrapper around this node that holds span information about it. It is intended to be a mostly see-through wrapper around whatever the inner node is. Parse is implemented on it in a way that automatically calculates the span information.

Implementations

impl<T: Parse> SpannableNode<T>

pub fn into_inner(self) -> T

Get the inner node, consuming the wrapper.

pub const fn to_inner(&self) -> &T

Get a reference to the inner node.

pub fn to_inner_mut(&mut self) -> &mut T

Get a mutable reference to the inner node.

pub fn deconstruct(&mut self) -> (&mut T, &mut Span)

Get mutable references to both the inner node and the span.

Trait Implementations

impl<T: Clone + Parse> Clone for SpannableNode<T>

fn clone(&self) -> SpannableNode<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Parse> Debug for SpannableNode<T>

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

Formats the value using the given formatter.

impl<T: Parse + Display> Display for SpannableNode<T>

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

Formats the value using the given formatter.

impl<T: Parse> From<T> for SpannableNode<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Parse + Hash> Hash for SpannableNode<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Parse + Debug> Parse for SpannableNode<T>

fn parse(lexer: &mut LexerBridge<'_>) -> ParseResult<Self>

where Self: Sized,

Given a lexer, try to parse a valid instance of this node.

fn parse_sep( lexer: &mut LexerBridge<'_>, join: Tokens, ) -> ParseResult<Vec<Self>>

where Self: Sized,

Parse multiple instances of this node, separated by a Tokens.

fn parse_sep_end( lexer: &mut LexerBridge<'_>, join: Tokens, end: Tokens, ) -> ParseResult<Vec<Self>>

where Self: Sized,

Parse multiple instances of this node, separated by a Tokens end ended by a (possibly different) Tokens.

impl<T: Parse + PartialEq> PartialEq for SpannableNode<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Parse> Spannable for SpannableNode<T>

fn span(&self) -> Span

Get the Span of the object

fn set_span(&mut self, span: Span)

Set the Span of the object. Possibly does nothing as implementation is optional.

impl<T: Parse + ToTokens> ToTokens for SpannableNode<T>

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

impl<T: Parse + Eq> Eq for SpannableNode<T>