Function expand_pattern_assertion

assert-struct-macros/src/expand.rs:76–128

Generate assertion code with error collection instead of immediate panic.

(value_expr: &TokenStream, pattern: &Pattern)

/// Generate assertion code with error collection instead of immediate panic.
fn expand_pattern_assertion(value_expr: &TokenStream, pattern: &Pattern) -> TokenStream {
    match pattern {
        Pattern::Simple(simple_pattern) => expand_simple_assertion(value_expr, simple_pattern),
        Pattern::String(string_pattern) => expand_string_assertion(value_expr, string_pattern),
        Pattern::Struct(struct_pattern) => expand_struct_assertion(value_expr, struct_pattern),
        Pattern::Comparison(comparison_pattern) => {
            expand_comparison_assertion(value_expr, comparison_pattern)
        }
        Pattern::Enum(enum_pattern) => {
            // Enum tuple variant - use collection version
            expand_enum_assertion(value_expr, enum_pattern)
        }
        Pattern::Tuple(tuple_pattern) => {
            // Plain tuple - use collection version for proper error collection
            expand_tuple_assertion(value_expr, tuple_pattern)
        }
        Pattern::Wildcard(_) => {
            // Wildcard patterns generate no assertions - they just verify the field exists
            // which is already handled by the struct/tuple destructuring
            quote! {}
        }
        Pattern::Range(range_pattern) => {
            // Generate improved range assertion with error collection
            expand_range_assertion(value_expr, range_pattern)
        }
        Pattern::Slice(slice_pattern) => {
            // Generate slice assertion with error collection
            expand_slice_assertion(value_expr, slice_pattern)
        }
        #[cfg(feature = "regex")]
        Pattern::Regex(regex_pattern) => {
            // Generate regex assertion with error collection
            expand_regex_assertion(value_expr, regex_pattern)
        }
        #[cfg(feature = "regex")]
        Pattern::Like(like_pattern) => {
            // Generate Like trait assertion with error collection
            expand_like_assertion(value_expr, like_pattern)
        }
        Pattern::Closure(closure_pattern) => {
            // Generate closure assertion with error collection
            expand_closure_assertion(value_expr, closure_pattern)
        }
        Pattern::Map(map_pattern) => {
            // Generate map assertion with error collection
            expand_map_assertion(value_expr, map_pattern)
        }
        Pattern::Set(set_pattern) => {
            // Generate set assertion with backtracking
            expand_set_assertion(value_expr, set_pattern)
        }
    }
}

/// Generate struct assertion with error collection for multiple field failures
fn expand_struct_assertion(value_expr: &TokenStream, pattern: &PatternStruct) -> TokenStream {