sipha 3.0.0

PEG parser, syntax trees, and code generation
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

#![cfg(feature = "std")]

use sipha::SyntaxKinds;
use sipha::prelude::*;

#[derive(Debug, Clone, Copy, PartialEq, Eq, SyntaxKinds)]
#[repr(u16)]
enum K {
    Root,
    Host,
    Body,
    Embedded,
    JsonRoot,
    JsonString,
    JsonLBrace,
    JsonRBrace,
    JsonColon,
    Ws,
}

fn host_grammar() -> BuiltGraph {
    let mut g = GrammarBuilder::new();
    g.set_trivia_rule("ws");

    g.parser_rule("start", |g| {
        g.node(K::Root, |g| {
            g.node(K::Host, |g| {
                g.call("body");
            });
        });
        g.accept();
    });

    g.lexer_rule("ws", |g| {
        g.trivia(K::Ws, |g| {
            g.zero_or_more(|g| {
                g.class(classes::WHITESPACE);
            });
        });
    });

    g.lexer_rule("body", |g| {
        g.token(K::Body, |g| {
            g.literal(b"{\"a\":\"b\"}");
        });
    });

    g.finish().unwrap()
}

fn json_grammar() -> BuiltGraph {
    let mut g = GrammarBuilder::new();
    g.set_trivia_rule("ws");

    g.parser_rule("start", |g| {
        g.node(K::JsonRoot, |g| {
            g.token(K::JsonLBrace, |g| {
                g.byte(b'{');
            });
            g.call("jstring");
            g.token(K::JsonColon, |g| {
                g.byte(b':');
            });
            g.call("jstring");
            g.token(K::JsonRBrace, |g| {
                g.byte(b'}');
            });
            g.skip();
        });
        g.end_of_input();
        g.accept();
    });

    g.lexer_rule("ws", |g| {
        g.trivia(K::Ws, |g| {
            g.zero_or_more(|g| {
                g.class(classes::WHITESPACE);
            });
        });
    });

    g.lexer_rule("jstring", |g| {
        g.token(K::JsonString, |g| {
            g.byte(b'"');
            g.zero_or_more(|g| {
                g.neg_lookahead(|g| {
                    g.byte(b'"');
                });
                g.class(CharClass::ANY);
            });
            g.byte(b'"');
        });
    });

    g.finish().unwrap()
}

#[test]
fn can_splice_embedded_tree_events() {
    let host = host_grammar();
    let json = json_grammar();
    let src = b"{\"a\":\"b\"}";

    let mut engine = Engine::new();
    let host_out = engine.parse(&host.as_graph(), src).unwrap();

    let (rewritten, errors) = apply_sublanguages(
        &mut engine,
        src,
        &host_out.tree_events,
        &[SubLanguage {
            host_kind: K::Host as SyntaxKind,
            span: EmbeddedSpan::TokenKind(K::Body as SyntaxKind),
            embedded: json.as_graph(),
            wrapper_kind: Some(K::Embedded as SyntaxKind),
            error_kind: Some(K::Embedded as SyntaxKind),
        }],
    );

    assert!(errors.is_empty(), "{errors:#?}");
    assert!(
        rewritten.iter().any(
            |e| matches!(e, TreeEvent::NodeOpen { kind, .. } if *kind == K::Embedded as SyntaxKind)
        ),
        "expected an Embedded wrapper node to be inserted"
    );
}