syster-base 0.2.1-alpha

Core library for SysML v2 and KerML parsing, AST, and semantic analysis
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use pest::Parser;
use syster::parser::sysml::{Rule, SysMLParser};
use syster::syntax::sysml::ast::{DefinitionMember, Element, UsageMember, parse_file};

#[test]
fn test_debug_extended_usage_parsing() {
    let source = r#"package Requirements {
    requirement def MassRequirement;
    
    requirement vehicleSpecification {
        requirement vehicleMassRequirement : MassRequirement;
    }
    
    requirement engineSpecification {
        requirement engineMassRequirement : MassRequirement;
    }
    
    #derivation connection {
        end #original ::> vehicleSpecification.vehicleMassRequirement;
        end #derive ::> engineSpecification.engineMassRequirement;
    }
}"#;

    println!("\n=== SOURCE ===");
    println!("{}", source);

    let mut pairs = SysMLParser::parse(Rule::file, source).expect("Parse should succeed");
    let file = parse_file(&mut pairs).expect("AST parse should succeed");

    println!("\n=== ELEMENTS ===");
    for elem in &file.elements {
        match elem {
            Element::Package(pkg) => {
                println!(
                    "Package: {}",
                    pkg.name.as_ref().unwrap_or(&"<unnamed>".to_string())
                );
                for member in &pkg.elements {
                    print_element(member, 1);
                }
            }
            Element::Definition(def) => {
                println!(
                    "Definition: {} (kind: {:?})",
                    def.name.as_ref().unwrap_or(&"<unnamed>".to_string()),
                    def.kind
                );
            }
            Element::Usage(usage) => {
                println!(
                    "Usage: {} (kind: {:?})",
                    usage.name.as_ref().unwrap_or(&"<unnamed>".to_string()),
                    usage.kind
                );
            }
            _ => {}
        }
    }
}

fn print_element(elem: &Element, indent: usize) {
    let prefix = "  ".repeat(indent);
    match elem {
        Element::Definition(def) => {
            println!(
                "{}Definition: {} (kind: {:?})",
                prefix,
                def.name.as_ref().unwrap_or(&"<unnamed>".to_string()),
                def.kind
            );
            for m in &def.body {
                print_definition_member(m, indent + 1);
            }
        }
        Element::Usage(usage) => {
            print_usage(usage, indent);
        }
        Element::Package(pkg) => {
            println!(
                "{}Package: {}",
                prefix,
                pkg.name.as_ref().unwrap_or(&"<unnamed>".to_string())
            );
        }
        _ => {}
    }
}

fn print_definition_member(member: &DefinitionMember, indent: usize) {
    let prefix = "  ".repeat(indent);
    match member {
        DefinitionMember::Usage(usage) => {
            print_usage(usage, indent);
        }
        DefinitionMember::Comment(c) => {
            println!("{}Comment: {:?}", prefix, c.content);
        }
        DefinitionMember::Import(i) => {
            println!("{}Import: {}", prefix, i.path);
        }
    }
}

fn print_usage(usage: &syster::syntax::sysml::ast::Usage, indent: usize) {
    let prefix = "  ".repeat(indent);
    println!(
        "{}Usage: {} (kind: {:?})",
        prefix,
        usage.name.as_ref().unwrap_or(&"<unnamed>".to_string()),
        usage.kind
    );
    println!(
        "{}  relationships.subsets: {:?}",
        prefix, usage.relationships.subsets
    );
    println!(
        "{}  relationships.typed_by: {:?}",
        prefix, usage.relationships.typed_by
    );
    println!(
        "{}  relationships.redefines: {:?}",
        prefix, usage.relationships.redefines
    );
    println!(
        "{}  relationships.references: {:?}",
        prefix, usage.relationships.references
    );
    println!("{}  expression_refs: {:?}", prefix, usage.expression_refs);
    for m in &usage.body {
        print_usage_member(m, indent + 1);
    }
}

fn print_usage_member(member: &UsageMember, indent: usize) {
    let prefix = "  ".repeat(indent);
    match member {
        UsageMember::Usage(usage) => {
            print_usage(usage, indent);
        }
        UsageMember::Comment(c) => {
            println!("{}Comment: {:?}", prefix, c.content);
        }
    }
}