parse_tree 0.0.7

A non-abstract syntax tree type
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

extern crate parse_tree;

use parse_tree::{
    Symbol, ParseTree, PtNodeId,
    algo::{AsParseTree, GetSymbol, GetText},
};

const WHITESPACE: Symbol = Symbol(0);
const NUMBER: Symbol = Symbol(1);
const STAR: Symbol = Symbol(2);
const MUL_EXPR: Symbol = Symbol(3);

struct TestTree {
    text: String,
    tree: ParseTree,
}

impl AsParseTree for TestTree {
    fn as_parse_tree(&self) -> &ParseTree {
        &self.tree
    }
}

impl GetText for TestTree {
    fn get_text(&self, id: PtNodeId) -> String {
        let range = self.tree[id].range();
        self.text[range].to_owned()
    }
}

impl GetSymbol for TestTree {
    fn get_symbol(&self, id: PtNodeId) -> String {
        let symbol = self.tree[id].symbol();
        let name = match symbol {
            WHITESPACE => "WHITESPACE",
            NUMBER => "NUMBER",
            STAR => "STAR",
            MUL_EXPR => "MUL_EXPR",
            _ => panic!("unknown symbol: {:?}", symbol)
        };
        name.to_owned()
    }
}

#[test]
fn top_down() {
    let text = "46 * 2";

    let tree = {
        let mut builder = parse_tree::TopDownBuilder::new();
        builder.start_internal(MUL_EXPR);
        builder.leaf(NUMBER, 2.into());
        builder.leaf(WHITESPACE, 1.into());
        builder.leaf(STAR, 1.into());
        builder.leaf(WHITESPACE, 1.into());
        builder.leaf(NUMBER, 1.into());
        builder.finish_internal();
        builder.finish()
    };
    let tree = TestTree {
        text: text.to_string(),
        tree
    };

    let debug = parse_tree::algo::debug_dump(&tree);
    assert_eq!(
        debug.trim(),
        r#"
MUL_EXPR@[0; 6)
  NUMBER@[0; 2) "46"
  WHITESPACE@[2; 3)
  STAR@[3; 4) "*"
  WHITESPACE@[4; 5)
  NUMBER@[5; 6) "2"
"#.trim()
    );
}

#[test]
fn bottom_up() {
    let text = "46 * 2";

    let tree = {
        let mut builder = parse_tree::BottomUpBuilder::new();
        builder.shift(NUMBER, 2.into());
        builder.shift(WHITESPACE, 1.into());
        builder.shift(STAR, 1.into());
        builder.shift(WHITESPACE, 1.into());
        builder.shift(NUMBER, 1.into());
        builder.reduce(MUL_EXPR, 5);
        builder.finish()
    };

    let tree = TestTree {
        text: text.to_string(),
        tree
    };

    let debug = parse_tree::algo::debug_dump(&tree);
    assert_eq!(
        debug.trim(),
        r#"
MUL_EXPR@[0; 6)
  NUMBER@[0; 2) "46"
  WHITESPACE@[2; 3)
  STAR@[3; 4) "*"
  WHITESPACE@[4; 5)
  NUMBER@[5; 6) "2"
"#.trim()
    );
}