xidl-parser 0.105.0

A IDL codegen.
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

use crate::{hir, parser::parser_text, semantic::recursive_schema_types};
use std::collections::BTreeSet;

fn lower(source: &str) -> hir::Specification {
    hir::Specification::from_typed_ast_with_properties_and_path(
        parser_text(source).unwrap(),
        [("expand_interface".into(), false.into())].into(),
        "graph.idl",
    )
    .unwrap()
}

#[test]
fn schema_cycles_follow_aliases_containers_and_inline_types_without_marking_leaves() {
    let source = r#"
module graph {
    typedef map<KeyNode, ValueNode> Lookup;
    struct KeyNode { Lookup links; };
    struct ValueNode { long value; };
    typedef Pair<TemplateNode, long> Boxed;
    struct TemplateNode { Boxed box; };
    typedef struct Inline { Alias next; } Alias;
    typedef union InlineChoice switch(long) { case 1: ChoiceAlias next; } ChoiceAlias;
    typedef enum InlineState { Idle } StateAlias;
    typedef long Numbers[2];
    enum Plain { Ready };
    native Native;
    const long LIMIT = 1;
    union Tree switch(long) {
        case 1: union Branch switch(long) { case 1: Tree parent; default: long count; } branch;
        case 2: enum Mode { Leaf } mode;
    };
};
"#;
    let spec = lower(source);
    let actual: BTreeSet<_> = recursive_schema_types(&spec)
        .into_iter()
        .map(|path| path.join("::"))
        .collect();
    let expected = [
        "Lookup",
        "KeyNode",
        "Boxed",
        "TemplateNode",
        "Alias",
        "ChoiceAlias",
        "Tree",
    ]
    .into_iter()
    .map(|name| format!("graph::{name}"))
    .collect();
    assert_eq!(actual, expected);
    let restored: hir::Specification =
        serde_json::from_str(&serde_json::to_string(&spec).unwrap()).unwrap();
    assert_eq!(
        recursive_schema_types(&restored),
        recursive_schema_types(&spec)
    );
}

#[test]
fn recursive_inline_typedef_members_preserve_boxing_decisions() {
    let spec = lower(
        r#"
        typedef struct Node { @optional Node next; long value; } NodeAlias;
        typedef union Link switch(long) { case 1: Link next; default: long value; } LinkAlias;
    "#,
    );
    for definition in &spec.0 {
        let hir::Definition::TypeDcl(hir::TypeDcl::TypedefDcl(alias)) = definition else {
            panic!("typedef")
        };
        match &alias.ty {
            hir::TypedefType::ConstrTypeDcl(hir::ConstrTypeDcl::StructDcl(node)) => {
                assert!(node.member[0].recursive);
                assert!(!node.member[1].recursive);
            }
            hir::TypedefType::ConstrTypeDcl(hir::ConstrTypeDcl::UnionDef(link)) => {
                assert!(link.case[0].element.recursive);
                assert!(!link.case[1].element.recursive);
            }
            _ => panic!("inline schema"),
        }
    }
}