Method parse_comma_separated

assert-struct-macros/src/pattern/tuple.rs:73–127

Parse a comma-separated list of tuple elements, supporting both positional and indexed syntax. Used inside tuple patterns to handle mixed syntax like ("foo", *1: "bar", "baz")

(input: ParseStream)

    /// Parse a comma-separated list of tuple elements, supporting both positional and indexed syntax.
    /// Used inside tuple patterns to handle mixed syntax like ("foo", *1: "bar", "baz")
    pub(crate) fn parse_comma_separated(input: ParseStream) -> syn::Result<Vec<Self>> {
        let mut elements = Vec::new();
        let mut position = 0;

        while !input.is_empty() {
            // Try to parse as indexed element by attempting FieldOperation parse
            let fork = input.fork();

            if fork.parse::<Pattern>().is_ok() && !fork.peek(Token![:]) {
                // Parse as positional pattern
                let pattern = input.parse()?;
                elements.push(TupleElement::Positional(Box::new(pattern)));
            } else {
                // Parse as indexed element
                let operations: FieldOperation = input.parse()?;
                let root_field = operations.root_field_name();

                // Validate that the index matches the current position
                match root_field {
                    FieldName::Index(index) if index == position => {
                        // Valid indexed element
                        let _: Token![:] = input.parse()?;
                        let pattern = input.parse()?;

                        elements.push(TupleElement::Indexed(Box::new(FieldAssertion {
                            operations,
                            pattern,
                        })));
                    }
                    FieldName::Index(index) => {
                        // Index doesn't match position
                        return Err(syn::Error::new(
                            input.span(),
                            format!("Index {} must match position {} in tuple", index, position),
                        ));
                    }
                    FieldName::Ident(_) => {
                        // Index doesn't match position
                        return Err(syn::Error::new(
                            input.span(),
                            "Operations like * can only be used with indexed elements (e.g., *0:, *1:)",
                        ));
                    }
                }
            }

            position += 1;

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

        Ok(elements)
    }
}