Struct syn::parse::StepCursor

pub struct StepCursor<'c, 'a> { /* fields omitted */ }

Cursor state associated with speculative parsing.

This type is the input of the closure provided to ParseStream::step.

Example

use proc_macro2::TokenTree;
use syn::Result;
use syn::parse::ParseStream;

// This function advances the stream past the next occurrence of `@`. If
// no `@` is present in the stream, the stream position is unchanged and
// an error is returned.
fn skip_past_next_at(input: ParseStream) -> Result<()> {
    input.step(|cursor| {
        let mut rest = *cursor;
        while let Some((tt, next)) = rest.token_tree() {
            match tt {
                TokenTree::Punct(ref punct) if punct.as_char() == '@' => {
                    return Ok(((), next));
                }
                _ => rest = next,
            }
        }
        Err(cursor.error("no `@` was found after this point"))
    })
}
#
# fn remainder_after_skipping_past_next_at(
#     input: ParseStream,
# ) -> Result<proc_macro2::TokenStream> {
#     skip_past_next_at(input)?;
#     input.parse()
# }
#
# fn main() {
#     use syn::parse::Parser;
#     let remainder = remainder_after_skipping_past_next_at
#         .parse_str("a @ b c")
#         .unwrap();
#     assert_eq!(remainder.to_string(), "b c");
# }

Methods

impl<'c, 'a> StepCursor<'c, 'a>

pub fn error<T: Display>(self, message: T) -> Error

Triggers an error at the current position of the parse stream.

The ParseStream::step invocation will return this same error without advancing the stream state.

Methods from Deref<Target = Cursor<'c>>

Trait Implementations

impl<'c, 'a> Clone for StepCursor<'c, 'a>

fn clone(&self) -> StepCursor<'c, 'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'c, 'a> Copy for StepCursor<'c, 'a>

impl<'c, 'a> Deref for StepCursor<'c, 'a>

type Target = Cursor<'c>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.