1use rowan::{ast::{support, AstChildren, AstNode}, Language};
3
4macro_rules! decl_ast_node {
5 ($node:ident, $kind:ident) => {
6 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
7 pub struct $node(SyntaxNode);
8 impl AstNode for $node {
9 type Language = Lang;
10
11 fn syntax(&self) -> &rowan::SyntaxNode<Self::Language> {
12 &self.0
13 }
14
15 fn can_cast(kind: <Self::Language as Language>::Kind) -> bool {
16 kind == SyntaxKind::$kind
17 }
18
19 fn cast(node: rowan::SyntaxNode<Self::Language>) -> Option<Self> {
20 if Self::can_cast(node.kind()) {
21 Some(Self(node))
22 } else {
23 None
24 }
25 }
26 }
27 impl core::fmt::Display for $node {
28 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
29 core::fmt::Display::fmt(self.syntax(), f)
30 }
31 }
32 };
33}
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
36pub enum Lang {}
37impl Language for Lang {
38 type Kind = SyntaxKind;
39
40 fn kind_to_raw(kind: Self::Kind) -> ::rowan::SyntaxKind {
41 kind.into()
42 }
43
44 fn kind_from_raw(raw: ::rowan::SyntaxKind) -> Self::Kind {
45 raw.into()
46 }
47}
48
49pub type SyntaxNode = ::rowan::SyntaxNode<Lang>;
50pub type SyntaxToken = ::rowan::SyntaxToken<Lang>;
51
52::peg::parser!(pub grammar parser<'b>(state: &'b ::rowan_peg_utils::ParseState<'input>) for str {
53 use SyntaxKind::*;
54
55 rule comment() = ()(()(g:({state.guard_none()})((g:({state.quiet().guard_token(COMMENT)}) s:$(((()(g:({state.guard_none()})(";" (g:({state.guard_none()})((quiet!{[^::char_classes::any!(@"\n")]}/expected!("<^\\n>"))){g.accept_none()})*){g.accept_none()})))) {g.accept_token(s)})){g.accept_none()}) / expected!("comment"))
56 rule whitespace() = ()(()(g:({state.guard_none()})((g:({state.quiet().guard_token(WHITESPACE)}) s:$(((()(g:({state.guard_none()})((g:({state.guard_none()})((quiet!{[::char_classes::any!(@" \t\r\n")]}/expected!("< \\t\\r\\n>"))){g.accept_none()})*){g.accept_none()})))) {g.accept_token(s)})){g.accept_none()}))
57 pub rule trivia() = _
58 rule _() = (g:({state.guard(TRIVIA)}) ((()(g:({state.guard_none()})(whitespace() (g:({state.guard_none()})((()(g:({state.guard_none()})(comment() whitespace()){g.accept_none()}))){g.accept_none()})*){g.accept_none()}))) {g.accept()})
59 rule ident() = ()(()(g:({state.guard_none()})((g:({state.quiet().guard_token(IDENT)}) s:$(((()(g:({state.guard_none()})(!(g:({state.quiet().guard_none()}) (quiet!{(quiet!{[::char_classes::any!(@"0-9")]}/expected!("<0-9>"))}) {g.accept_none()}) (g:({state.guard_none()})((()(g:({state.guard_none()})((quiet!{[::char_classes::any!(@"0-9a-zA-Z_-")]}/expected!("<0-9a-zA-Z_->"))){g.accept_none()}) / ()(g:({state.guard_none()})((quiet!{[^::char_classes::any!(@"\u{00}-\u{a0}")]}/expected!("<^\\u{00}-\\u{a0}>"))){g.accept_none()}))){g.accept_none()})+){g.accept_none()})))) {g.accept_token(s)})){g.accept_none()}) / expected!("ident"))
60 rule number() = ()(()(g:({state.guard_none()})((g:({state.quiet().guard_token(NUMBER)}) s:$(((()(g:({state.guard_none()})((g:({state.guard_none()})((quiet!{[::char_classes::any!(@"0-9")]}/expected!("<0-9>"))){g.accept_none()})+){g.accept_none()})))) {g.accept_token(s)})){g.accept_none()}) / expected!("number"))
61 rule string() = ()(()(g:({state.guard_none()})((g:({state.quiet().guard_token(STRING)}) s:$(((()(g:({state.guard_none()})("\"" (g:({state.guard_none()})((quiet!{[^::char_classes::any!(@"\"\r\n")]}/expected!("<^\\\"\\r\\n>"))){g.accept_none()})* "\""){g.accept_none()})))) {g.accept_token(s)})){g.accept_none()}) / expected!("string"))
62 rule matches() = ()(()(g:({state.guard_none()})((g:({state.quiet().guard_token(MATCHES)}) s:$(((()(g:({state.guard_none()})("<" (g:({state.guard_none()})((quiet!{[^::char_classes::any!(@"\x3e\r\n")]}/expected!("<^\\x3e\\r\\n>"))){g.accept_none()})* ">"){g.accept_none()})))) {g.accept_token(s)})){g.accept_none()}) / expected!("matches"))
63 rule label() = (g:({state.guard(LABEL)}) ((()(g:({state.guard_none()})(ident()){g.accept_none()}) / ()(g:({state.guard_none()})(string()){g.accept_none()}))) {g.accept()})
64 rule repeat_rest() = (g:({state.guard(REPEAT_REST)}) ((()(g:({state.guard_none()})((g:({state.quiet().guard_token(STAR)}) s:$(("*")) {g.accept_token(s)}) (g:({state.guard_none()})((()(g:({state.guard_none()})(number()){g.accept_none()}))){g.accept_none()})?){g.accept_none()}))) {g.accept()})
65 rule repeat() = (g:({state.guard(REPEAT)}) ((()(g:({state.guard_none()})((g:({state.quiet().guard_token(PLUS)}) s:$(("+")) {g.accept_token(s)})){g.accept_none()}) / ()(g:({state.guard_none()})(number() (g:({state.guard_none()})((()(g:({state.guard_none()})(repeat_rest()){g.accept_none()}))){g.accept_none()})?){g.accept_none()}) / ()(g:({state.guard_none()})(repeat_rest()){g.accept_none()}))) {g.accept()})
66 rule pat_expect() = (g:({state.guard(PAT_EXPECT)}) ((()(g:({state.guard_none()})((g:({state.quiet().guard_token(AT)}) s:$(("@")) {g.accept_token(s)}) label()){g.accept_none()}))) {g.accept()})
67 rule pat_atom() = (g:({state.guard(PAT_ATOM)}) ((()(g:({state.guard_none()})(ident() !(g:({state.quiet().guard_none()}) (quiet!{(()(g:({state.guard_none()})(_() (g:({state.quiet().guard_token(EQ)}) s:$(("=")) {g.accept_token(s)})){g.accept_none()}))}) {g.accept_none()})){g.accept_none()}) / ()(g:({state.guard_none()})(string()){g.accept_none()}) / ()(g:({state.guard_none()})(matches()){g.accept_none()}) / ()(g:({state.guard_none()})((g:({state.quiet().guard_token(L_BRACK)}) s:$(("[")) {g.accept_token(s)}) _() pat_choice() _() (g:({state.quiet().guard_token(R_BRACK)}) s:$(("]")) {g.accept_token(s)})){g.accept_none()}) / ()(g:({state.guard_none()})((g:({state.quiet().guard_token(L_PAREN)}) s:$(("(")) {g.accept_token(s)}) _() pat_choice() _() (g:({state.quiet().guard_token(R_PAREN)}) s:$((")")) {g.accept_token(s)})){g.accept_none()}))) {g.accept()})
68 rule pat_op() = (g:({state.guard(PAT_OP)}) ((()(g:({state.guard_none()})((g:({state.quiet().guard_token(AMP)}) s:$(("&")) {g.accept_token(s)}) pat_atom()){g.accept_none()}) / ()(g:({state.guard_none()})((g:({state.quiet().guard_token(BANG)}) s:$(("!")) {g.accept_token(s)}) pat_atom()){g.accept_none()}) / ()(g:({state.guard_none()})((g:({state.quiet().guard_token(TILDE)}) s:$(("~")) {g.accept_token(s)}) pat_atom()){g.accept_none()}) / ()(g:({state.guard_none()})((g:({state.quiet().guard_token(DOLLAR)}) s:$(("$")) {g.accept_token(s)}) pat_atom()){g.accept_none()}) / ()(g:({state.guard_none()})(repeat() _() pat_atom()){g.accept_none()}) / ()(g:({state.guard_none()})(pat_atom()){g.accept_none()}))) {g.accept()})
69 rule pat_list() = (g:({state.guard(PAT_LIST)}) ((()(g:({state.guard_none()})(pat_op() (g:({state.guard_none()})((()(g:({state.guard_none()})(_() pat_op()){g.accept_none()}))){g.accept_none()})*){g.accept_none()}))) {g.accept()})
70 rule pat_choice() = (g:({state.guard(PAT_CHOICE)}) ((()(g:({state.guard_none()})(pat_list() (g:({state.guard_none()})((()(g:({state.guard_none()})(_() (g:({state.quiet().guard_token(SLASH)}) s:$(("/")) {g.accept_token(s)}) _() pat_list()){g.accept_none()}))){g.accept_none()})* (g:({state.guard_none()})((()(g:({state.guard_none()})(_() pat_expect()){g.accept_none()}))){g.accept_none()})?){g.accept_none()}))) {g.accept()})
71 rule named() = (g:({state.guard(NAMED)}) ((()(g:({state.guard_none()})(ident() _() (g:({state.quiet().guard_token(EQ)}) s:$(("=")) {g.accept_token(s)}) _()){g.accept_none()}))) {g.accept()})
72 rule decl() = (g:({state.guard(DECL)}) ((()(g:({state.guard_none()})(named() pat_choice()){g.accept_none()}))) {g.accept()})
73 rule export() = (g:({state.guard(EXPORT)}) ((()(g:({state.guard_none()})((g:({state.guard_none()})((()(g:({state.guard_none()})(named()){g.accept_none()}))){g.accept_none()})? ident()){g.accept_none()}))) {g.accept()})
74 rule export_list() = (g:({state.guard(EXPORT_LIST)}) ((()(g:({state.guard_none()})((g:({state.quiet().guard_token(EXPORTS_KW)}) s:$(("exports")) {g.accept_token(s)}) _() (g:({state.quiet().guard_token(L_BRACK)}) s:$(("[")) {g.accept_token(s)}) _() (g:({state.guard_none()})((()(g:({state.guard_none()})(export() _()){g.accept_none()}))){g.accept_none()})* (g:({state.quiet().guard_token(R_BRACK)}) s:$(("]")) {g.accept_token(s)})){g.accept_none()}))) {g.accept()})
75 pub rule decl_list() = (g:({state.guard(DECL_LIST)}) ((()(g:({state.guard_none()})(_() (g:({state.guard_none()})((()(g:({state.guard_none()})(export_list() _()){g.accept_none()}))){g.accept_none()})? (g:({state.guard_none()})((()(g:({state.guard_none()})(decl() _()){g.accept_none()}))){g.accept_none()})+){g.accept_none()}))) {g.accept()})
76});
77#[repr(u16)]
78#[allow(non_camel_case_types)]
79#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
80pub enum SyntaxKind {
81 COMMENT = 0,
82 WHITESPACE,
83 TRIVIA,
84 IDENT,
85 NUMBER,
86 STRING,
87 MATCHES,
88 LABEL,
89 REPEAT_REST,
90 STAR,
91 REPEAT,
92 PLUS,
93 PAT_EXPECT,
94 AT,
95 PAT_ATOM,
96 L_PAREN,
97 R_PAREN,
98 PAT_OP,
99 AMP,
100 BANG,
101 TILDE,
102 DOLLAR,
103 PAT_LIST,
104 PAT_CHOICE,
105 SLASH,
106 NAMED,
107 EQ,
108 DECL,
109 EXPORT,
110 EXPORT_LIST,
111 EXPORTS_KW,
112 L_BRACK,
113 R_BRACK,
114 DECL_LIST,
115}
116impl From<::rowan::SyntaxKind> for SyntaxKind { fn from(kind: ::rowan::SyntaxKind) -> Self { ::core::assert!(kind.0 <= Self::DECL_LIST as u16); unsafe { ::core::mem::transmute::<u16, SyntaxKind>(kind.0) } } }
117impl From<SyntaxKind> for ::rowan::SyntaxKind { fn from(kind: SyntaxKind) -> Self { ::rowan::SyntaxKind(kind as u16) } }
118decl_ast_node!(Trivia, TRIVIA);
119impl Trivia {
120 pub fn comment_tokens(&self) -> impl Iterator<Item = SyntaxToken> {
121 ::rowan_peg_utils::tokens(self.syntax(), SyntaxKind::COMMENT)
122 }
123 pub fn whitespace_tokens(&self) -> impl Iterator<Item = SyntaxToken> {
124 ::rowan_peg_utils::tokens(self.syntax(), SyntaxKind::WHITESPACE)
125 }
126}
127decl_ast_node!(Label, LABEL);
128impl Label {
129 pub fn ident(&self) -> Option<SyntaxToken> {
130 support::token(self.syntax(), SyntaxKind::IDENT)
131 }
132 pub fn string(&self) -> Option<SyntaxToken> {
133 support::token(self.syntax(), SyntaxKind::STRING)
134 }
135}
136decl_ast_node!(RepeatRest, REPEAT_REST);
137impl RepeatRest {
138 pub fn number(&self) -> Option<SyntaxToken> {
139 support::token(self.syntax(), SyntaxKind::NUMBER)
140 }
141 pub fn star(&self) -> SyntaxToken {
142 support::token(self.syntax(), SyntaxKind::STAR).unwrap()
143 }
144}
145decl_ast_node!(Repeat, REPEAT);
146impl Repeat {
147 pub fn number(&self) -> Option<SyntaxToken> {
148 support::token(self.syntax(), SyntaxKind::NUMBER)
149 }
150 pub fn plus(&self) -> Option<SyntaxToken> {
151 support::token(self.syntax(), SyntaxKind::PLUS)
152 }
153 pub fn repeat_rest(&self) -> Option<RepeatRest> {
154 support::child(self.syntax())
155 }
156}
157decl_ast_node!(PatExpect, PAT_EXPECT);
158impl PatExpect {
159 pub fn at(&self) -> SyntaxToken {
160 support::token(self.syntax(), SyntaxKind::AT).unwrap()
161 }
162 pub fn label(&self) -> Label {
163 support::child(self.syntax()).unwrap()
164 }
165}
166decl_ast_node!(PatAtom, PAT_ATOM);
167impl PatAtom {
168 pub fn ident(&self) -> Option<SyntaxToken> {
169 support::token(self.syntax(), SyntaxKind::IDENT)
170 }
171 pub fn l_brack(&self) -> Option<SyntaxToken> {
172 support::token(self.syntax(), SyntaxKind::L_BRACK)
173 }
174 pub fn l_paren(&self) -> Option<SyntaxToken> {
175 support::token(self.syntax(), SyntaxKind::L_PAREN)
176 }
177 pub fn matches(&self) -> Option<SyntaxToken> {
178 support::token(self.syntax(), SyntaxKind::MATCHES)
179 }
180 pub fn pat_choice(&self) -> Option<PatChoice> {
181 support::child(self.syntax())
182 }
183 pub fn r_brack(&self) -> Option<SyntaxToken> {
184 support::token(self.syntax(), SyntaxKind::R_BRACK)
185 }
186 pub fn r_paren(&self) -> Option<SyntaxToken> {
187 support::token(self.syntax(), SyntaxKind::R_PAREN)
188 }
189 pub fn string(&self) -> Option<SyntaxToken> {
190 support::token(self.syntax(), SyntaxKind::STRING)
191 }
192 pub fn trivias(&self) -> AstChildren<Trivia> {
193 support::children(self.syntax())
194 }
195}
196decl_ast_node!(PatOp, PAT_OP);
197impl PatOp {
198 pub fn amp(&self) -> Option<SyntaxToken> {
199 support::token(self.syntax(), SyntaxKind::AMP)
200 }
201 pub fn bang(&self) -> Option<SyntaxToken> {
202 support::token(self.syntax(), SyntaxKind::BANG)
203 }
204 pub fn dollar(&self) -> Option<SyntaxToken> {
205 support::token(self.syntax(), SyntaxKind::DOLLAR)
206 }
207 pub fn pat_atom(&self) -> PatAtom {
208 support::child(self.syntax()).unwrap()
209 }
210 pub fn repeat(&self) -> Option<Repeat> {
211 support::child(self.syntax())
212 }
213 pub fn tilde(&self) -> Option<SyntaxToken> {
214 support::token(self.syntax(), SyntaxKind::TILDE)
215 }
216 pub fn trivia(&self) -> Option<Trivia> {
217 support::child(self.syntax())
218 }
219}
220decl_ast_node!(PatList, PAT_LIST);
221impl PatList {
222 pub fn pat_ops(&self) -> AstChildren<PatOp> {
223 support::children(self.syntax())
224 }
225 pub fn trivias(&self) -> AstChildren<Trivia> {
226 support::children(self.syntax())
227 }
228}
229decl_ast_node!(PatChoice, PAT_CHOICE);
230impl PatChoice {
231 pub fn pat_expect(&self) -> Option<PatExpect> {
232 support::child(self.syntax())
233 }
234 pub fn pat_lists(&self) -> AstChildren<PatList> {
235 support::children(self.syntax())
236 }
237 pub fn slash_tokens(&self) -> impl Iterator<Item = SyntaxToken> {
238 ::rowan_peg_utils::tokens(self.syntax(), SyntaxKind::SLASH)
239 }
240 pub fn trivias(&self) -> AstChildren<Trivia> {
241 support::children(self.syntax())
242 }
243}
244decl_ast_node!(Named, NAMED);
245impl Named {
246 pub fn eq(&self) -> SyntaxToken {
247 support::token(self.syntax(), SyntaxKind::EQ).unwrap()
248 }
249 pub fn ident(&self) -> SyntaxToken {
250 support::token(self.syntax(), SyntaxKind::IDENT).unwrap()
251 }
252 pub fn trivias(&self) -> AstChildren<Trivia> {
253 support::children(self.syntax())
254 }
255}
256decl_ast_node!(Decl, DECL);
257impl Decl {
258 pub fn named(&self) -> Named {
259 support::child(self.syntax()).unwrap()
260 }
261 pub fn pat_choice(&self) -> PatChoice {
262 support::child(self.syntax()).unwrap()
263 }
264}
265decl_ast_node!(Export, EXPORT);
266impl Export {
267 pub fn ident(&self) -> SyntaxToken {
268 support::token(self.syntax(), SyntaxKind::IDENT).unwrap()
269 }
270 pub fn named(&self) -> Option<Named> {
271 support::child(self.syntax())
272 }
273}
274decl_ast_node!(ExportList, EXPORT_LIST);
275impl ExportList {
276 pub fn exports(&self) -> AstChildren<Export> {
277 support::children(self.syntax())
278 }
279 pub fn exports_kw(&self) -> SyntaxToken {
280 support::token(self.syntax(), SyntaxKind::EXPORTS_KW).unwrap()
281 }
282 pub fn l_brack(&self) -> SyntaxToken {
283 support::token(self.syntax(), SyntaxKind::L_BRACK).unwrap()
284 }
285 pub fn r_brack(&self) -> SyntaxToken {
286 support::token(self.syntax(), SyntaxKind::R_BRACK).unwrap()
287 }
288 pub fn trivias(&self) -> AstChildren<Trivia> {
289 support::children(self.syntax())
290 }
291}
292decl_ast_node!(DeclList, DECL_LIST);
293impl DeclList {
294 pub fn decls(&self) -> AstChildren<Decl> {
295 support::children(self.syntax())
296 }
297 pub fn export_list(&self) -> Option<ExportList> {
298 support::child(self.syntax())
299 }
300 pub fn trivias(&self) -> AstChildren<Trivia> {
301 support::children(self.syntax())
302 }
303}
304