Function process_tuple_elements

assert-struct-macros/src/expand.rs:326–375

Helper function to process tuple elements and generate match patterns and assertions. This function handles the common pattern of iterating through elements and: - Creating `_` patterns for wildcards (which need no assertions) - Creating named bindings for other patterns and generating their assertions - Handling field operations like dereferencing # Parameters - `elements`: The tuple elements t

(
    elements: &[TupleElement],
    prefix: &str,
)

/// - `match_patterns`: TokenStreams for use in match arms or destructuring
/// - `assertions`: TokenStreams for the generated assertion code
fn process_tuple_elements(
    elements: &[TupleElement],
    prefix: &str,
) -> (Vec<TokenStream>, Vec<TokenStream>) {
    let mut match_patterns = Vec::new();
    let mut assertions = Vec::new();

    for (i, tuple_element) in elements.iter().enumerate() {
        match tuple_element {
            TupleElement::Positional(pattern) => {
                match &**pattern {
                    Pattern::Wildcard(PatternWildcard { .. }) => {
                        // Wildcard patterns use `_` in the match pattern
                        match_patterns.push(quote! { _ });
                    }
                    _ => {
                        // Non-wildcard patterns need a binding and assertion
                        let name = quote::format_ident!("{}{}", prefix, i);
                        match_patterns.push(quote! { #name });

                        // Generate assertion with error collection
                        let assertion = expand_pattern_assertion(&quote! { #name }, pattern);
                        assertions.push(assertion);
                    }
                }
            }
            TupleElement::Indexed(boxed_elem) => {
                let pattern = &boxed_elem.pattern;

                match pattern {
                    Pattern::Wildcard(PatternWildcard { .. }) => {
                        // Wildcard patterns use `_` in the match pattern
                        match_patterns.push(quote! { _ });
                    }
                    _ => {
                        // Non-wildcard patterns need a binding and assertion
                        let name = quote::format_ident!("{}{}", prefix, i);
                        match_patterns.push(quote! { #name });

                        // Expand the indexed FieldAssertion starting from the bound element name
                        let assertion = expand_field_assertion(&quote! { #name }, boxed_elem);
                        assertions.push(assertion);
                    }
                }
            }
        }
    }

    (match_patterns, assertions)
}

/// Generate assertion for plain tuples with error collection.
/// Uses match expressions for consistency with enum tuple handling.