test_parse_stream.rs

Enable keyboard shortcuts

#![allow(clippy::items_after_statements, clippy::let_underscore_untyped)]

use proc_macro2::{Delimiter, Group, Punct, Spacing, Span, TokenStream, TokenTree};

use quote::quote;

use syn::ext::IdentExt as _;

use syn::parse::discouraged::AnyDelimiter;

use syn::parse::{ParseStream, Parser as _, Result};

use syn::{parenthesized, token, Ident, Lifetime, Token};

#[test]

fn test_peek_punct() {

    let tokens = quote!(+= + =);

    fn assert(input: ParseStream) -> Result<()> {

        assert!(input.peek(Token![+]));

        assert!(input.peek(Token![+=]));

        let _: Token![+] = input.parse()?;

        assert!(input.peek(Token![=]));

        assert!(!input.peek(Token![==]));

        assert!(!input.peek(Token![+]));

        let _: Token![=] = input.parse()?;

        assert!(input.peek(Token![+]));

        assert!(!input.peek(Token![+=]));

        let _: Token![+] = input.parse()?;

        let _: Token![=] = input.parse()?;

        Ok(())

    assert.parse2(tokens).unwrap();

#[test]

fn test_peek_lifetime() {

    // 'static ;

    let tokens = TokenStream::from_iter([

        TokenTree::Punct(Punct::new('\'', Spacing::Joint)),

        TokenTree::Ident(Ident::new("static", Span::call_site())),

        TokenTree::Punct(Punct::new(';', Spacing::Alone)),

]);

    fn assert(input: ParseStream) -> Result<()> {

        assert!(input.peek(Lifetime));

        assert!(input.peek2(Token![;]));

        assert!(!input.peek2(Token![static]));

        let _: Lifetime = input.parse()?;

        assert!(input.peek(Token![;]));

        let _: Token![;] = input.parse()?;

        Ok(())

    assert.parse2(tokens).unwrap();

#[test]

fn test_peek_not_lifetime() {

    // ' static

    let tokens = TokenStream::from_iter([

        TokenTree::Punct(Punct::new('\'', Spacing::Alone)),

        TokenTree::Ident(Ident::new("static", Span::call_site())),

]);

    fn assert(input: ParseStream) -> Result<()> {

        assert!(!input.peek(Lifetime));

        assert!(input.parse::<Option<Punct>>()?.is_none());

        let _: TokenTree = input.parse()?;

        assert!(input.peek(Token![static]));

        let _: Token![static] = input.parse()?;

        Ok(())

    assert.parse2(tokens).unwrap();

#[test]

fn test_peek_ident() {

    let tokens = quote!(static var);

    fn assert(input: ParseStream) -> Result<()> {

        assert!(!input.peek(Ident));

        assert!(input.peek(Ident::peek_any));

        assert!(input.peek(Token![static]));

        let _: Token![static] = input.parse()?;

        assert!(input.peek(Ident));

        assert!(input.peek(Ident::peek_any));

        let _: Ident = input.parse()?;

        Ok(())

    assert.parse2(tokens).unwrap();

#[test]

fn test_peek_groups() {

    // pub ( :: ) «∅ ! = ∅» static

    let tokens = TokenStream::from_iter([

        TokenTree::Ident(Ident::new("pub", Span::call_site())),

        TokenTree::Group(Group::new(

            Delimiter::Parenthesis,

            TokenStream::from_iter([

                TokenTree::Punct(Punct::new(':', Spacing::Joint)),

                TokenTree::Punct(Punct::new(':', Spacing::Alone)),

]),

)),

        TokenTree::Group(Group::new(

            Delimiter::None,

            TokenStream::from_iter([

                TokenTree::Punct(Punct::new('!', Spacing::Alone)),

                TokenTree::Punct(Punct::new('=', Spacing::Alone)),

]),

)),

        TokenTree::Ident(Ident::new("static", Span::call_site())),

]);

    fn assert(input: ParseStream) -> Result<()> {

        assert!(input.peek2(token::Paren));

        assert!(input.peek3(token::Group));

        assert!(input.peek3(Token![!]));

        let _: Token![pub] = input.parse()?;

        assert!(input.peek(token::Paren));

        assert!(!input.peek(Token![::]));

        assert!(!input.peek2(Token![::]));

        assert!(input.peek2(Token![!]));

        assert!(input.peek2(token::Group));

        assert!(input.peek3(Token![=]));

        assert!(!input.peek3(Token![static]));

        let content;

        parenthesized!(content in input);

        assert!(content.peek(Token![::]));

        assert!(content.peek2(Token![:]));

        assert!(!content.peek3(token::Group));

        assert!(!content.peek3(Token![!]));

        assert!(input.peek(token::Group));

        assert!(input.peek(Token![!]));

        let _: Token![::] = content.parse()?;

        assert!(input.peek(token::Group));

        assert!(input.peek(Token![!]));

        assert!(input.peek2(Token![=]));

        assert!(input.peek3(Token![static]));

        assert!(!input.peek2(Token![static]));

        let implicit = input.fork();

        let explicit = input.fork();

        let _: Token![!] = implicit.parse()?;

        assert!(implicit.peek(Token![=]));

        assert!(implicit.peek2(Token![static]));

        let _: Token![=] = implicit.parse()?;

        assert!(implicit.peek(Token![static]));

        let (delimiter, _span, grouped) = explicit.parse_any_delimiter()?;

        assert_eq!(delimiter, Delimiter::None);

        assert!(grouped.peek(Token![!]));

        assert!(grouped.peek2(Token![=]));

        assert!(!grouped.peek3(Token![static]));

        let _: Token![!] = grouped.parse()?;

        assert!(grouped.peek(Token![=]));

        assert!(!grouped.peek2(Token![static]));

        let _: Token![=] = grouped.parse()?;

        assert!(!grouped.peek(Token![static]));

        let _: TokenStream = input.parse()?;

        Ok(())

    assert.parse2(tokens).unwrap();