Method parse

assert-struct-macros/src/pattern/struct_pattern.rs:30–89

Parses a struct pattern with braces. # Example Input ```text User { name: "Alice", age: >= 18, .. } { name: "Alice" } // anonymous struct (.. implied, never required) ``` Handles both named structs (with a path) and wildcard structs (starting with `_`).

(input: syn::parse::ParseStream)

    ///
    /// Handles both named structs (with a path) and wildcard structs (starting with `_`).
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let node_id = next_node_id();

        // Check if this is a wildcard/anonymous struct pattern: _ { ... } or { ... }
        let path = if input.peek(Token![_]) {
            let _: Token![_] = input.parse()?;
            None // wildcard has no path
        } else if input.peek(syn::token::Brace) {
            None // bare { ... } — anonymous struct
        } else {
            // Named struct pattern: TypeName { ... }
            Some(input.parse::<syn::Path>()?)
        };

        // Parse the braced contents
        let content;
        syn::braced!(content in input);

        // Parse comma-separated field assertions with optional rest pattern (..)
        let mut fields = Punctuated::new();
        let mut rest = false;

        while !content.is_empty() {
            // Check for rest pattern (..) which allows partial matching
            if content.peek(Token![..]) {
                let _: Token![..] = content.parse()?;
                rest = true;
                break;
            }

            fields.push_value(content.parse()?);

            if content.is_empty() {
                break;
            }

            let comma: Token![,] = content.parse()?;
            fields.push_punct(comma);

            // Rest pattern can appear after a comma
            if content.peek(Token![..]) {
                let _: Token![..] = content.parse()?;
                rest = true;
                break;
            }
        }

        // Wildcard struct patterns always imply partial matching since the type
        // is unknown, so .. is never required (but still accepted if written).
        if path.is_none() {
            rest = true;
        }

        Ok(PatternStruct {
            node_id,
            path,
            fields,
            rest,