alef 0.79.2

Opinionated polyglot binding generator for Rust libraries
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Regression tests for `FieldResolver::ir_wire_optional_fields` -- the IR-derived fact that a
//! field's JSON key may be entirely absent from the wire format
//! (`#[serde(skip_serializing_if = "...")]`) even though the underlying Rust field is always
//! present. This is a genuinely different fact from `FieldResolver::ir_field_sets`'s `optional`
//! set, which tracks `Option<T>`-ness -- see `FieldDef::serde_skip_serializing_if`.
//!
//! Split into its own file rather than added to `field_access/tests.rs`: that file is already
//! over the repo's 1,000-line cap (see `file-modularization` in CLAUDE.md), so new test
//! coverage goes into a fresh module instead of growing it. ~keep

use super::FieldResolver;
use crate::core::ir::{FieldDef, TypeDef};

#[test]
fn a_required_vec_with_skip_serializing_if_is_wire_optional() {
    let type_def = TypeDef {
        name: "DataNode".to_string(),
        fields: vec![FieldDef {
            name: "children".to_string(),
            optional: false,
            serde_skip_serializing_if: true,
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    };

    let wire_optional = FieldResolver::ir_wire_optional_fields(&[type_def]);
    assert!(wire_optional.contains("children"));
}

/// `ir_field_sets`'s `optional` set must NOT pick up a `serde_skip_serializing_if` field that
/// is not itself `Option<T>` -- conflating the two would make e.g. the Rust e2e backend emit
/// `.as_ref().unwrap()` against a plain `Vec<T>`, which does not compile.
#[test]
fn a_required_vec_with_skip_serializing_if_is_not_ir_optional() {
    let type_def = TypeDef {
        name: "DataNode".to_string(),
        fields: vec![FieldDef {
            name: "children".to_string(),
            optional: false,
            serde_skip_serializing_if: true,
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    };

    let (_reachable, _excluded, optional) = FieldResolver::ir_field_sets(&[type_def]);
    assert!(
        !optional.contains("children"),
        "a required Vec<T> field must not be treated as Option<T>-optional just because it \
         carries skip_serializing_if"
    );
}

/// A field with neither `Option<T>` nor `skip_serializing_if` must not appear in either set.
#[test]
fn a_plain_required_field_is_neither_optional_nor_wire_optional() {
    let type_def = TypeDef {
        name: "DataNode".to_string(),
        fields: vec![FieldDef {
            name: "kind".to_string(),
            optional: false,
            serde_skip_serializing_if: false,
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    };

    let wire_optional = FieldResolver::ir_wire_optional_fields(std::slice::from_ref(&type_def));
    assert!(!wire_optional.contains("kind"));
    let (_reachable, _excluded, optional) = FieldResolver::ir_field_sets(&[type_def]);
    assert!(!optional.contains("kind"));
}

/// `is_wire_optional_key` is a bare-key lookup (unlike `is_optional`, which resolves a full
/// dotted path): `wire_optional_fields` is IR-derived from bare field names with no notion of
/// nesting depth, so a resolver built from `ir_wire_optional_fields` must answer per key, not
/// per full path.
#[test]
fn is_wire_optional_key_matches_the_bare_key_regardless_of_nesting() {
    let type_def = TypeDef {
        name: "DataNode".to_string(),
        fields: vec![FieldDef {
            name: "children".to_string(),
            serde_skip_serializing_if: true,
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    };
    let wire_optional = FieldResolver::ir_wire_optional_fields(&[type_def]);
    let resolver = FieldResolver::new(
        &std::collections::HashMap::new(),
        &std::collections::HashSet::new(),
        &std::collections::HashSet::new(),
        &std::collections::HashSet::new(),
        &std::collections::HashSet::new(),
    )
    .with_wire_optional_fields(wire_optional);

    assert!(resolver.is_wire_optional_key("children"));
    assert!(!resolver.is_wire_optional_key("data"));
}