zirium 0.4.0

Lossless textual MLIR syntax parsing and semantic processing
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
103
104
105
106
107
108
109
110
111

use zirium::{
    dialect::DialectRegistry,
    diff::{ChangeField, DiffLimits, DiffOptions, compare},
    parser::ParsedFile,
    query::{changed, changes, dialect, diff_op_input, op},
    semantic::{Document, LoweringMode, lower_with_dialect_registry},
};

fn document(source: &str) -> Document {
    let registry = DialectRegistry::baseline();
    let parsed = ParsedFile::parse_with_registry(source.as_bytes(), registry).unwrap();
    lower_with_dialect_registry(&parsed, LoweringMode::Strict, registry)
        .document
        .unwrap()
}

#[test]
fn typed_change_filters_project_and_navigate_on_the_after_document() {
    let before =
        document("module { %value = arith.constant 4 : i32 \"test.use\"(%value) : (i32) -> () }");
    let after = document(
        "module { %renamed = arith.constant 8 : i32 \"test.use\"(%renamed) : (i32) -> () }",
    );
    let comparison = compare(
        &before,
        &after,
        DialectRegistry::baseline(),
        DiffOptions::default(),
        DiffLimits::default(),
    )
    .unwrap();

    let rewired = changes().filter(changed(ChangeField::Attributes) & dialect("arith"));
    assert_eq!(comparison.query(&rewired).unwrap().len(), 1);

    let consumers = rewired.after().users().unique().names();
    assert_eq!(comparison.query(&consumers).unwrap(), ["test.use"]);
    assert_eq!(comparison.query(&rewired.before().count()).unwrap(), 1);
    assert_eq!(comparison.query(&rewired.attr("value")).unwrap(), ["8"]);
    assert_eq!(comparison.query(&rewired.result_types()).unwrap(), ["i32"]);
    assert_eq!(
        comparison
            .query(&rewired.after().users().operand_types())
            .unwrap(),
        ["i32"]
    );
    assert_eq!(
        comparison.query(&changes().names().sort().min()).unwrap(),
        ["arith.constant"]
    );

    let roots = rewired.after().root(op("builtin.module")).unique();
    assert_eq!(comparison.query(&roots).unwrap().len(), 1);
    assert_eq!(
        comparison
            .query(
                &rewired
                    .after()
                    .root(op("builtin.module"))
                    .subtree()
                    .filter(op("test.use"))
                    .names(),
            )
            .unwrap(),
        ["test.use"]
    );
    assert_eq!(
        comparison
            .query(&changes().reverse().head(1).tail(1).count())
            .unwrap(),
        1
    );
}

#[test]
fn typed_projected_graph_traversals_use_the_selected_document() {
    let before = document(
        "module { %x = arith.constant 1 : i32 %y = arith.constant 2 : i32 %z = arith.addi %x, %y : i32 }",
    );
    let after = document(
        "module { %x = arith.constant 1 : i32 %y = arith.constant 2 : i32 %z = arith.addi %y, %x : i32 }",
    );
    let comparison = compare(
        &before,
        &after,
        DialectRegistry::baseline(),
        DiffOptions::default(),
        DiffLimits::default(),
    )
    .unwrap();
    let changed_add = changes().filter(changed(ChangeField::Operands)).after();
    let expected = ["arith.constant", "arith.constant", "arith.addi"];
    assert_eq!(
        comparison.query(&changed_add.slice().names()).unwrap(),
        expected
    );
    assert_eq!(
        comparison.query(&changed_add.closure().names()).unwrap(),
        expected
    );
    assert_eq!(
        comparison.query(&changed_add.reachable().names()).unwrap(),
        expected
    );
    assert_eq!(
        comparison
            .query(&changed_add.fixpoint(&diff_op_input().closure()).names())
            .unwrap(),
        expected
    );
}