mofmt 0.6.0

Modelica language formatter
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

use super::{SyntaxEvent, SyntaxKind, Token};

/// Return the parse tree built from the collection returned from parser
pub fn build_tree(tokens: Vec<Token>, events: Vec<SyntaxEvent>) -> Tree {
    let mut stack = Vec::new();
    let mut tokens = tokens.into_iter();
    let mut events = events;

    assert!(matches!(events.pop(), Some(SyntaxEvent::Exit)));

    for event in events {
        match event {
            SyntaxEvent::Enter(kind) => stack.push(Tree::new(kind)),
            SyntaxEvent::Exit => {
                let tree = stack.pop().unwrap();
                if tree.len() > 0 {
                    stack.last_mut().unwrap().push(Child::Tree(tree));
                }
            }
            SyntaxEvent::Advance => {
                let token = tokens.next().unwrap();
                stack.last_mut().unwrap().push(Child::Token(token));
            }
        }
    }

    assert!(tokens.next().is_none());
    assert!(stack.len() == 1);

    stack.pop().unwrap()
}

#[derive(Debug)]
pub struct Tree {
    pub kind: SyntaxKind,
    pub children: Vec<Child>,
}

#[derive(Debug)]
pub enum Child {
    Token(Token),
    Tree(Tree),
}

impl Tree {
    pub fn new(kind: SyntaxKind) -> Self {
        Tree {
            kind,
            children: Vec::new(),
        }
    }

    pub fn push(&mut self, child: Child) {
        self.children.push(child);
    }

    pub fn len(&self) -> usize {
        self.children.len()
    }

    pub fn start(&self) -> &Token {
        match self.children.first().unwrap() {
            Child::Token(token) => token,
            Child::Tree(tree) => tree.start(),
        }
    }

    pub fn end(&self) -> &Token {
        match self.children.last().unwrap() {
            Child::Token(token) => token,
            Child::Tree(tree) => tree.end(),
        }
    }

    pub fn is_multiline(&self) -> bool {
        let first = self.start();
        let last = self.end();
        first.start.line < last.end.line
    }

    pub fn contains(&self, kind: SyntaxKind) -> bool {
        let mut contains = false;
        for child in self.children.iter() {
            if let Child::Tree(tree) = child {
                if tree.kind == kind {
                    contains = true;
                } else {
                    contains = tree.contains(kind);
                }
            }
            if contains {
                return contains;
            }
        }
        contains
    }
}

#[cfg(test)]
mod tests {
    use super::super::{parse, ModelicaToken};

    use super::*;

    fn tree(source: &str, start: SyntaxKind) -> Tree {
        let parsed = parse("none", source, start);
        build_tree(parsed.tokens, parsed.events)
    }

    #[test]
    fn test_empty_rules() {
        const SOURCE: &str = r#"annotation (choices(choice = 0 "Foo", choice = 1 "Bar"))"#;
        let tree = tree(SOURCE, SyntaxKind::Description);
        assert_eq!(tree.len(), 1);
    }

    #[test]
    fn test_start_and_end() {
        const SOURCE: &str = r#""descr" annotation ()"#;
        let tree = tree(SOURCE, SyntaxKind::Description);
        assert_eq!(tree.len(), 2);
        if let Child::Tree(annotation) = tree.children.get(1).unwrap() {
            assert_eq!(annotation.len(), 2);
        } else {
            panic!("annotation not found");
        }
        assert_eq!(tree.start().kind, ModelicaToken::String);
        assert_eq!(tree.start().text, r#""descr""#);
        assert_eq!(tree.end().kind, ModelicaToken::RParen);
        assert_eq!(tree.end().end.pos, 21);
    }
}