assert-struct-macros 0.4.2

Procedural macro implementation for assert-struct
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! Slice pattern types.
//!
//! Handles slice patterns: [1, 2, 3], [> 0, < 10]

use syn::{Token, parse::Parse};

use crate::parse::next_node_id;
use crate::pattern::Pattern;

/// Slice pattern: [1, 2, 3] or [1, .., 5]
#[derive(Debug, Clone)]
pub(crate) struct PatternSlice {
    pub node_id: usize,
    pub span: proc_macro2::Span,
    pub elements: Vec<Pattern>,
}

impl Parse for PatternSlice {
    /// Parses a slice pattern: [pattern, pattern, ...]
    ///
    /// # Example Input
    /// ```text
    /// [1, 2, 3]
    /// [> 0, < 10, == 5]
    /// ```
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        // Capture the span of the `[` token before consuming it.
        let span = input.span();
        let content;
        syn::bracketed!(content in input);

        // Parse the comma-separated list of patterns
        let elements = parse_pattern_list(&content)?;

        Ok(PatternSlice {
            node_id: next_node_id(),
            span,
            elements,
        })
    }
}

/// Parse a comma-separated list of patterns inside brackets.
fn parse_pattern_list(input: syn::parse::ParseStream) -> syn::Result<Vec<Pattern>> {
    let mut patterns = Vec::new();

    while !input.is_empty() {
        patterns.push(input.parse()?);

        if !input.is_empty() {
            let _: Token![,] = input.parse()?;
        }
    }

    Ok(patterns)
}