rdf_parsers/jsonld/
parser.rs

1use crate::TokenTrait;
2pub type SyntaxNode = rowan::SyntaxNode<Lang>;
3#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, logos :: Logos)]
4# [logos (subpattern HEX = r#"([0-9]|[A-F]|[a-f])"#)]
5# [logos (subpattern JSON_STRING = r#""(([^\x{22}\x{5C}]|\\\u0022|\\\u005C|\\\u002F|\\b|\\f|\\n|\\r|\\t|\\u(?&HEX)(?&HEX)(?&HEX)(?&HEX)))*""#)]
6# [logos (subpattern JSON_NUMBER = r#"(-)?(0|[1-9]([0-9])*)(\.([0-9])+)?([eE]([+-])?([0-9])+)?"#)]
7#[repr(u16)]
8pub enum SyntaxKind {
9    Eof = 0,
10    #[regex(r"[ \t\n\r]+")]
11    WhiteSpace,
12    #[regex(r"#[^\n]*", allow_greedy = true)]
13    Comment,
14    #[doc = r" producings"]
15    JsonArray,
16    JsonObject,
17    JsonString,
18    JsonValue,
19    JsonldDoc,
20    Member,
21    MemberList,
22    ValueList,
23    #[doc = r" terminals"]
24    #[token(",")]
25    Comma,
26    #[token(":")]
27    Colon,
28    #[token("[")]
29    SqOpen,
30    #[token("]")]
31    SqClose,
32    #[token("false")]
33    FalseLit,
34    #[token("null")]
35    NullLit,
36    #[token("true")]
37    TrueLit,
38    #[token("{")]
39    CurlyOpen,
40    #[token("}")]
41    CurlyClose,
42    #[regex("(?&JSON_NUMBER)")]
43    JsonNumber,
44    #[regex("(?&JSON_STRING)")]
45    StringToken,
46    Error,
47    ROOT,
48}
49impl From<SyntaxKind> for rowan::SyntaxKind {
50    fn from(kind: SyntaxKind) -> Self {
51        Self(kind as u16)
52    }
53}
54impl From<rowan::SyntaxKind> for SyntaxKind {
55    fn from(value: rowan::SyntaxKind) -> Self {
56        assert!(value.0 <= SyntaxKind::ROOT as u16);
57        unsafe { std::mem::transmute::<u16, SyntaxKind>(value.0) }
58    }
59}
60#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
61pub enum Lang {}
62impl rowan::Language for Lang {
63    type Kind = SyntaxKind;
64    fn kind_from_raw(raw: rowan::SyntaxKind) -> Self::Kind {
65        assert!(raw.0 <= SyntaxKind::ROOT as u16);
66        unsafe { std::mem::transmute::<u16, SyntaxKind>(raw.0) }
67    }
68    fn kind_to_raw(kind: Self::Kind) -> rowan::SyntaxKind {
69        kind.into()
70    }
71}
72mod definitions {
73    use super::*;
74    #[derive(Debug, Clone, Copy)]
75    pub struct Rule {
76        pub kind: SyntaxKind,
77        pub state: usize,
78    }
79    impl Rule {
80        pub fn new(kind: SyntaxKind) -> Self {
81            match kind {
82                SyntaxKind::JsonldDoc => Rule {
83                    kind,
84                    state: 1usize,
85                },
86                SyntaxKind::JsonObject => Rule {
87                    kind,
88                    state: 4usize,
89                },
90                SyntaxKind::JsonArray => Rule {
91                    kind,
92                    state: 4usize,
93                },
94                SyntaxKind::MemberList => Rule {
95                    kind,
96                    state: 4usize,
97                },
98                SyntaxKind::Member => Rule {
99                    kind,
100                    state: 3usize,
101                },
102                SyntaxKind::JsonValue => Rule {
103                    kind,
104                    state: 1usize,
105                },
106                SyntaxKind::ValueList => Rule {
107                    kind,
108                    state: 4usize,
109                },
110                SyntaxKind::JsonString => Rule {
111                    kind,
112                    state: 1usize,
113                },
114                SyntaxKind::Comma => Rule { kind, state: 0 },
115                SyntaxKind::Colon => Rule { kind, state: 0 },
116                SyntaxKind::SqOpen => Rule { kind, state: 0 },
117                SyntaxKind::SqClose => Rule { kind, state: 0 },
118                SyntaxKind::FalseLit => Rule { kind, state: 0 },
119                SyntaxKind::NullLit => Rule { kind, state: 0 },
120                SyntaxKind::TrueLit => Rule { kind, state: 0 },
121                SyntaxKind::CurlyOpen => Rule { kind, state: 0 },
122                SyntaxKind::CurlyClose => Rule { kind, state: 0 },
123                SyntaxKind::JsonNumber => Rule { kind, state: 0 },
124                SyntaxKind::StringToken => Rule { kind, state: 0 },
125                _ => panic!("Unknown rule kind {:?}", kind),
126            }
127        }
128    }
129    pub fn first_tokens(kind: SyntaxKind) -> &'static [SyntaxKind] {
130        match kind {
131            SyntaxKind::JsonArray => &[SyntaxKind::SqOpen],
132            SyntaxKind::JsonObject => &[SyntaxKind::CurlyOpen],
133            SyntaxKind::JsonString => &[],
134            SyntaxKind::JsonValue => &[
135                SyntaxKind::CurlyOpen,
136                SyntaxKind::FalseLit,
137                SyntaxKind::NullLit,
138                SyntaxKind::SqOpen,
139                SyntaxKind::TrueLit,
140            ],
141            SyntaxKind::JsonldDoc => &[
142                SyntaxKind::CurlyOpen,
143                SyntaxKind::FalseLit,
144                SyntaxKind::NullLit,
145                SyntaxKind::SqOpen,
146                SyntaxKind::TrueLit,
147            ],
148            SyntaxKind::Member => &[],
149            SyntaxKind::MemberList => &[],
150            SyntaxKind::ValueList => &[
151                SyntaxKind::CurlyOpen,
152                SyntaxKind::FalseLit,
153                SyntaxKind::NullLit,
154                SyntaxKind::SqOpen,
155                SyntaxKind::TrueLit,
156            ],
157            SyntaxKind::Comma => &[SyntaxKind::Comma],
158            SyntaxKind::Colon => &[SyntaxKind::Colon],
159            SyntaxKind::SqOpen => &[SyntaxKind::SqOpen],
160            SyntaxKind::SqClose => &[SyntaxKind::SqClose],
161            SyntaxKind::FalseLit => &[SyntaxKind::FalseLit],
162            SyntaxKind::NullLit => &[SyntaxKind::NullLit],
163            SyntaxKind::TrueLit => &[SyntaxKind::TrueLit],
164            SyntaxKind::CurlyOpen => &[SyntaxKind::CurlyOpen],
165            SyntaxKind::CurlyClose => &[SyntaxKind::CurlyClose],
166            SyntaxKind::JsonNumber => &[SyntaxKind::JsonNumber],
167            SyntaxKind::StringToken => &[SyntaxKind::StringToken],
168            _ => &[],
169        }
170    }
171    #[doc = r" Returns the minimum error cost that `kind` must incur when `tok`"]
172    #[doc = r" is the current token.  0 means the token is reachable (or the rule"]
173    #[doc = r" is nullable); positive means the rule cannot make progress without"]
174    #[doc = r" at least that much error cost."]
175    pub fn min_error_for_token(kind: SyntaxKind, tok: SyntaxKind) -> isize {
176        match kind {
177            SyntaxKind::JsonArray => match tok {
178                SyntaxKind::Colon
179                | SyntaxKind::Comma
180                | SyntaxKind::CurlyClose
181                | SyntaxKind::CurlyOpen
182                | SyntaxKind::FalseLit
183                | SyntaxKind::JsonNumber
184                | SyntaxKind::NullLit
185                | SyntaxKind::SqClose
186                | SyntaxKind::SqOpen
187                | SyntaxKind::StringToken
188                | SyntaxKind::TrueLit => 0,
189                _ => kind.max_error_value(),
190            },
191            SyntaxKind::JsonObject => match tok {
192                SyntaxKind::Colon
193                | SyntaxKind::Comma
194                | SyntaxKind::CurlyClose
195                | SyntaxKind::CurlyOpen
196                | SyntaxKind::FalseLit
197                | SyntaxKind::JsonNumber
198                | SyntaxKind::NullLit
199                | SyntaxKind::SqClose
200                | SyntaxKind::SqOpen
201                | SyntaxKind::StringToken
202                | SyntaxKind::TrueLit => 0,
203                _ => kind.max_error_value(),
204            },
205            SyntaxKind::JsonString => match tok {
206                SyntaxKind::StringToken => 0,
207                _ => kind.max_error_value(),
208            },
209            SyntaxKind::JsonValue => match tok {
210                SyntaxKind::Colon
211                | SyntaxKind::Comma
212                | SyntaxKind::CurlyClose
213                | SyntaxKind::CurlyOpen
214                | SyntaxKind::FalseLit
215                | SyntaxKind::JsonNumber
216                | SyntaxKind::NullLit
217                | SyntaxKind::SqClose
218                | SyntaxKind::SqOpen
219                | SyntaxKind::StringToken
220                | SyntaxKind::TrueLit => 0,
221                _ => kind.max_error_value(),
222            },
223            SyntaxKind::JsonldDoc => match tok {
224                SyntaxKind::Colon
225                | SyntaxKind::Comma
226                | SyntaxKind::CurlyClose
227                | SyntaxKind::CurlyOpen
228                | SyntaxKind::FalseLit
229                | SyntaxKind::JsonNumber
230                | SyntaxKind::NullLit
231                | SyntaxKind::SqClose
232                | SyntaxKind::SqOpen
233                | SyntaxKind::StringToken
234                | SyntaxKind::TrueLit => 0,
235                _ => kind.max_error_value(),
236            },
237            SyntaxKind::Member => match tok {
238                SyntaxKind::Colon
239                | SyntaxKind::Comma
240                | SyntaxKind::CurlyClose
241                | SyntaxKind::CurlyOpen
242                | SyntaxKind::FalseLit
243                | SyntaxKind::JsonNumber
244                | SyntaxKind::NullLit
245                | SyntaxKind::SqClose
246                | SyntaxKind::SqOpen
247                | SyntaxKind::StringToken
248                | SyntaxKind::TrueLit => 0,
249                _ => kind.max_error_value(),
250            },
251            SyntaxKind::MemberList => match tok {
252                SyntaxKind::Colon
253                | SyntaxKind::Comma
254                | SyntaxKind::CurlyClose
255                | SyntaxKind::CurlyOpen
256                | SyntaxKind::FalseLit
257                | SyntaxKind::JsonNumber
258                | SyntaxKind::NullLit
259                | SyntaxKind::SqClose
260                | SyntaxKind::SqOpen
261                | SyntaxKind::StringToken
262                | SyntaxKind::TrueLit => 0,
263                _ => kind.max_error_value(),
264            },
265            SyntaxKind::ValueList => match tok {
266                SyntaxKind::Colon
267                | SyntaxKind::Comma
268                | SyntaxKind::CurlyClose
269                | SyntaxKind::CurlyOpen
270                | SyntaxKind::FalseLit
271                | SyntaxKind::JsonNumber
272                | SyntaxKind::NullLit
273                | SyntaxKind::SqClose
274                | SyntaxKind::SqOpen
275                | SyntaxKind::StringToken
276                | SyntaxKind::TrueLit => 0,
277                _ => kind.max_error_value(),
278            },
279            SyntaxKind::Comma => match tok {
280                SyntaxKind::Comma => 0,
281                _ => kind.max_error_value(),
282            },
283            SyntaxKind::Colon => match tok {
284                SyntaxKind::Colon => 0,
285                _ => kind.max_error_value(),
286            },
287            SyntaxKind::SqOpen => match tok {
288                SyntaxKind::SqOpen => 0,
289                _ => kind.max_error_value(),
290            },
291            SyntaxKind::SqClose => match tok {
292                SyntaxKind::SqClose => 0,
293                _ => kind.max_error_value(),
294            },
295            SyntaxKind::FalseLit => match tok {
296                SyntaxKind::FalseLit => 0,
297                _ => kind.max_error_value(),
298            },
299            SyntaxKind::NullLit => match tok {
300                SyntaxKind::NullLit => 0,
301                _ => kind.max_error_value(),
302            },
303            SyntaxKind::TrueLit => match tok {
304                SyntaxKind::TrueLit => 0,
305                _ => kind.max_error_value(),
306            },
307            SyntaxKind::CurlyOpen => match tok {
308                SyntaxKind::CurlyOpen => 0,
309                _ => kind.max_error_value(),
310            },
311            SyntaxKind::CurlyClose => match tok {
312                SyntaxKind::CurlyClose => 0,
313                _ => kind.max_error_value(),
314            },
315            SyntaxKind::JsonNumber => match tok {
316                SyntaxKind::JsonNumber => 0,
317                _ => kind.max_error_value(),
318            },
319            SyntaxKind::StringToken => match tok {
320                SyntaxKind::StringToken => 0,
321                _ => kind.max_error_value(),
322            },
323            _ => 0,
324        }
325    }
326    #[doc = r" Precomputed dist(q, a): minimum insertion cost to reach a point"]
327    #[doc = r" where terminal `terminal` can be matched, starting from parser"]
328    #[doc = r" state `(kind, state)`.  Returns 0 as the conservative default"]
329    #[doc = r" (admissible — parent context might accept the terminal after a pop)."]
330    pub fn state_dist(kind: SyntaxKind, state: usize, terminal: SyntaxKind) -> isize {
331        match (kind, state, terminal) {
332            (SyntaxKind::JsonArray, 1usize, _) => match terminal {
333                SyntaxKind::SqClose => 0,
334                _ => 4isize,
335            },
336            (SyntaxKind::JsonArray, 2usize, _) => match terminal {
337                SyntaxKind::Colon => 1isize,
338                SyntaxKind::Comma => 1isize,
339                SyntaxKind::CurlyClose => 1isize,
340                _ => 0,
341            },
342            (SyntaxKind::JsonArray, 3usize, _) => match terminal {
343                SyntaxKind::JsonNumber
344                | SyntaxKind::StringToken
345                | SyntaxKind::CurlyOpen
346                | SyntaxKind::FalseLit
347                | SyntaxKind::NullLit
348                | SyntaxKind::SqOpen
349                | SyntaxKind::TrueLit => 0,
350                _ => 1isize,
351            },
352            (SyntaxKind::JsonArray, 4usize, _) => match terminal {
353                SyntaxKind::SqOpen => 0,
354                _ => 4isize,
355            },
356            (SyntaxKind::JsonObject, 1usize, _) => match terminal {
357                SyntaxKind::CurlyClose => 0,
358                _ => 2isize,
359            },
360            (SyntaxKind::JsonObject, 2usize, _) => match terminal {
361                SyntaxKind::StringToken | SyntaxKind::CurlyClose => 0,
362                _ => 1isize,
363            },
364            (SyntaxKind::JsonObject, 3usize, _) => match terminal {
365                SyntaxKind::StringToken => 0,
366                _ => 1isize,
367            },
368            (SyntaxKind::JsonObject, 4usize, _) => match terminal {
369                SyntaxKind::CurlyOpen => 0,
370                _ => 2isize,
371            },
372            (SyntaxKind::JsonString, 1usize, _) => match terminal {
373                SyntaxKind::StringToken => 0,
374                _ => 1isize,
375            },
376            (SyntaxKind::JsonValue, 1usize, _) => match terminal {
377                SyntaxKind::JsonNumber
378                | SyntaxKind::StringToken
379                | SyntaxKind::CurlyOpen
380                | SyntaxKind::FalseLit
381                | SyntaxKind::NullLit
382                | SyntaxKind::SqOpen
383                | SyntaxKind::TrueLit => 0,
384                _ => 1isize,
385            },
386            (SyntaxKind::JsonValue, 2usize, _) => match terminal {
387                SyntaxKind::CurlyOpen => 0,
388                _ => 2isize,
389            },
390            (SyntaxKind::JsonValue, 3usize, _) => match terminal {
391                SyntaxKind::SqOpen => 0,
392                _ => 4isize,
393            },
394            (SyntaxKind::JsonValue, 4usize, _) => match terminal {
395                SyntaxKind::StringToken => 0,
396                _ => 1isize,
397            },
398            (SyntaxKind::JsonValue, 5usize, _) => match terminal {
399                SyntaxKind::JsonNumber => 0,
400                _ => 1isize,
401            },
402            (SyntaxKind::JsonValue, 6usize, _) => match terminal {
403                SyntaxKind::TrueLit => 0,
404                _ => 1isize,
405            },
406            (SyntaxKind::JsonValue, 7usize, _) => match terminal {
407                SyntaxKind::FalseLit => 0,
408                _ => 1isize,
409            },
410            (SyntaxKind::JsonValue, 8usize, _) => match terminal {
411                SyntaxKind::NullLit => 0,
412                _ => 1isize,
413            },
414            (SyntaxKind::JsonldDoc, 1usize, _) => match terminal {
415                SyntaxKind::JsonNumber
416                | SyntaxKind::StringToken
417                | SyntaxKind::CurlyOpen
418                | SyntaxKind::FalseLit
419                | SyntaxKind::NullLit
420                | SyntaxKind::SqOpen
421                | SyntaxKind::TrueLit => 0,
422                _ => 1isize,
423            },
424            (SyntaxKind::Member, 1usize, _) => match terminal {
425                SyntaxKind::JsonNumber
426                | SyntaxKind::StringToken
427                | SyntaxKind::CurlyOpen
428                | SyntaxKind::FalseLit
429                | SyntaxKind::NullLit
430                | SyntaxKind::SqOpen
431                | SyntaxKind::TrueLit => 0,
432                _ => 1isize,
433            },
434            (SyntaxKind::Member, 2usize, _) => match terminal {
435                SyntaxKind::JsonNumber => 3isize,
436                SyntaxKind::StringToken => 3isize,
437                SyntaxKind::Comma => 4isize,
438                SyntaxKind::CurlyClose => 4isize,
439                SyntaxKind::CurlyOpen => 3isize,
440                SyntaxKind::FalseLit => 3isize,
441                SyntaxKind::NullLit => 3isize,
442                SyntaxKind::SqClose => 4isize,
443                SyntaxKind::SqOpen => 3isize,
444                SyntaxKind::TrueLit => 3isize,
445                _ => 0,
446            },
447            (SyntaxKind::Member, 3usize, _) => match terminal {
448                SyntaxKind::StringToken => 0,
449                _ => 1isize,
450            },
451            (SyntaxKind::MemberList, 2usize, _) => match terminal {
452                SyntaxKind::StringToken => 0,
453                _ => 1isize,
454            },
455            (SyntaxKind::MemberList, 3usize, _) => match terminal {
456                SyntaxKind::JsonNumber => 3isize,
457                SyntaxKind::StringToken => 2isize,
458                SyntaxKind::Colon => 3isize,
459                SyntaxKind::CurlyClose => 3isize,
460                SyntaxKind::CurlyOpen => 3isize,
461                SyntaxKind::FalseLit => 3isize,
462                SyntaxKind::NullLit => 3isize,
463                SyntaxKind::SqClose => 3isize,
464                SyntaxKind::SqOpen => 3isize,
465                SyntaxKind::TrueLit => 3isize,
466                _ => 0,
467            },
468            (SyntaxKind::MemberList, 4usize, _) => match terminal {
469                SyntaxKind::StringToken => 0,
470                _ => 1isize,
471            },
472            (SyntaxKind::ValueList, 2usize, _) => match terminal {
473                SyntaxKind::JsonNumber
474                | SyntaxKind::StringToken
475                | SyntaxKind::CurlyOpen
476                | SyntaxKind::FalseLit
477                | SyntaxKind::NullLit
478                | SyntaxKind::SqOpen
479                | SyntaxKind::TrueLit => 0,
480                _ => 1isize,
481            },
482            (SyntaxKind::ValueList, 3usize, _) => match terminal {
483                SyntaxKind::JsonNumber => 2isize,
484                SyntaxKind::StringToken => 2isize,
485                SyntaxKind::Colon => 3isize,
486                SyntaxKind::CurlyClose => 3isize,
487                SyntaxKind::CurlyOpen => 2isize,
488                SyntaxKind::FalseLit => 2isize,
489                SyntaxKind::NullLit => 2isize,
490                SyntaxKind::SqClose => 3isize,
491                SyntaxKind::SqOpen => 2isize,
492                SyntaxKind::TrueLit => 2isize,
493                _ => 0,
494            },
495            (SyntaxKind::ValueList, 4usize, _) => match terminal {
496                SyntaxKind::JsonNumber
497                | SyntaxKind::StringToken
498                | SyntaxKind::CurlyOpen
499                | SyntaxKind::FalseLit
500                | SyntaxKind::NullLit
501                | SyntaxKind::SqOpen
502                | SyntaxKind::TrueLit => 0,
503                _ => 1isize,
504            },
505            _ => 0,
506        }
507    }
508    impl crate::a_star::ParserTrait for Rule {
509        type Kind = SyntaxKind;
510        fn step(
511            &self,
512            element: &crate::a_star::Element<Self>,
513            state: &mut crate::a_star::AStar<Self>,
514        ) {
515            match (self.kind, self.state) {
516                (SyntaxKind::JsonldDoc, 0usize) => {
517                    if let Some(parent) = element.pop() {
518                        state.add_element(parent);
519                    }
520                }
521                (SyntaxKind::JsonldDoc, 1usize) => {
522                    state.add_element_checked(
523                        element
524                            .pop_push(Rule {
525                                kind: self.kind,
526                                state: 0usize,
527                            })
528                            .push(Rule {
529                                kind: SyntaxKind::JsonValue,
530                                state: 1usize,
531                            }),
532                        SyntaxKind::JsonValue,
533                    );
534                }
535                (SyntaxKind::JsonObject, 0usize) => {
536                    if let Some(parent) = element.pop() {
537                        state.add_element(parent);
538                    }
539                }
540                (SyntaxKind::JsonObject, 1usize) => {
541                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::CurlyClose);
542                    state.add_element(matched.pop_push(Rule {
543                        kind: self.kind,
544                        state: 0usize,
545                    }));
546                    if let Some(fb) = fb {
547                        state.add_element(fb.pop_push(Rule {
548                            kind: self.kind,
549                            state: 0usize,
550                        }));
551                    }
552                }
553                (SyntaxKind::JsonObject, 2usize) => {
554                    state.add_element(element.pop_push(Rule {
555                        kind: self.kind,
556                        state: 1usize,
557                    }));
558                    state.add_element(element.pop_push(Rule {
559                        kind: self.kind,
560                        state: 3usize,
561                    }));
562                }
563                (SyntaxKind::JsonObject, 3usize) => {
564                    state.add_element_checked(
565                        element
566                            .pop_push(Rule {
567                                kind: self.kind,
568                                state: 1usize,
569                            })
570                            .push(Rule {
571                                kind: SyntaxKind::MemberList,
572                                state: 4usize,
573                            }),
574                        SyntaxKind::MemberList,
575                    );
576                }
577                (SyntaxKind::JsonObject, 4usize) => {
578                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::CurlyOpen);
579                    state.add_element(matched.pop_push(Rule {
580                        kind: self.kind,
581                        state: 2usize,
582                    }));
583                    if let Some(fb) = fb {
584                        state.add_element(fb.pop_push(Rule {
585                            kind: self.kind,
586                            state: 2usize,
587                        }));
588                    }
589                }
590                (SyntaxKind::JsonArray, 0usize) => {
591                    if let Some(parent) = element.pop() {
592                        state.add_element(parent);
593                    }
594                }
595                (SyntaxKind::JsonArray, 1usize) => {
596                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::SqClose);
597                    state.add_element(matched.pop_push(Rule {
598                        kind: self.kind,
599                        state: 0usize,
600                    }));
601                    if let Some(fb) = fb {
602                        state.add_element(fb.pop_push(Rule {
603                            kind: self.kind,
604                            state: 0usize,
605                        }));
606                    }
607                }
608                (SyntaxKind::JsonArray, 2usize) => {
609                    state.add_element(element.pop_push(Rule {
610                        kind: self.kind,
611                        state: 1usize,
612                    }));
613                    state.add_element(element.pop_push(Rule {
614                        kind: self.kind,
615                        state: 3usize,
616                    }));
617                }
618                (SyntaxKind::JsonArray, 3usize) => {
619                    state.add_element_checked(
620                        element
621                            .pop_push(Rule {
622                                kind: self.kind,
623                                state: 1usize,
624                            })
625                            .push(Rule {
626                                kind: SyntaxKind::ValueList,
627                                state: 4usize,
628                            }),
629                        SyntaxKind::ValueList,
630                    );
631                }
632                (SyntaxKind::JsonArray, 4usize) => {
633                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::SqOpen);
634                    state.add_element(matched.pop_push(Rule {
635                        kind: self.kind,
636                        state: 2usize,
637                    }));
638                    if let Some(fb) = fb {
639                        state.add_element(fb.pop_push(Rule {
640                            kind: self.kind,
641                            state: 2usize,
642                        }));
643                    }
644                }
645                (SyntaxKind::MemberList, 0usize) => {
646                    if let Some(parent) = element.pop() {
647                        state.add_element(parent);
648                    }
649                }
650                (SyntaxKind::MemberList, 1usize) => {
651                    state.add_element(element.pop_push(Rule {
652                        kind: self.kind,
653                        state: 3usize,
654                    }));
655                    state.add_element(element.pop_push(Rule {
656                        kind: self.kind,
657                        state: 0usize,
658                    }));
659                }
660                (SyntaxKind::MemberList, 2usize) => {
661                    state.add_element_checked(
662                        element
663                            .pop_push(Rule {
664                                kind: self.kind,
665                                state: 1usize,
666                            })
667                            .push(Rule {
668                                kind: SyntaxKind::Member,
669                                state: 3usize,
670                            }),
671                        SyntaxKind::Member,
672                    );
673                }
674                (SyntaxKind::MemberList, 3usize) => {
675                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::Comma);
676                    state.add_element(matched.pop_push(Rule {
677                        kind: self.kind,
678                        state: 2usize,
679                    }));
680                    if let Some(fb) = fb {
681                        state.add_element(fb.pop_push(Rule {
682                            kind: self.kind,
683                            state: 2usize,
684                        }));
685                    }
686                }
687                (SyntaxKind::MemberList, 4usize) => {
688                    state.add_element(element.pop_push(Rule {
689                        kind: self.kind,
690                        state: 2usize,
691                    }));
692                }
693                (SyntaxKind::Member, 0usize) => {
694                    if let Some(parent) = element.pop() {
695                        state.add_element(parent);
696                    }
697                }
698                (SyntaxKind::Member, 1usize) => {
699                    state.add_element_checked(
700                        element
701                            .pop_push(Rule {
702                                kind: self.kind,
703                                state: 0usize,
704                            })
705                            .push(Rule {
706                                kind: SyntaxKind::JsonValue,
707                                state: 1usize,
708                            }),
709                        SyntaxKind::JsonValue,
710                    );
711                }
712                (SyntaxKind::Member, 2usize) => {
713                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::Colon);
714                    state.add_element(matched.pop_push(Rule {
715                        kind: self.kind,
716                        state: 1usize,
717                    }));
718                    if let Some(fb) = fb {
719                        state.add_element(fb.pop_push(Rule {
720                            kind: self.kind,
721                            state: 1usize,
722                        }));
723                    }
724                }
725                (SyntaxKind::Member, 3usize) => {
726                    state.add_element_checked(
727                        element
728                            .pop_push(Rule {
729                                kind: self.kind,
730                                state: 2usize,
731                            })
732                            .push(Rule {
733                                kind: SyntaxKind::JsonString,
734                                state: 1usize,
735                            }),
736                        SyntaxKind::JsonString,
737                    );
738                }
739                (SyntaxKind::JsonValue, 0usize) => {
740                    if let Some(parent) = element.pop() {
741                        state.add_element(parent);
742                    }
743                }
744                (SyntaxKind::JsonValue, 1usize) => {
745                    state.add_element(element.pop_push(Rule {
746                        kind: self.kind,
747                        state: 2usize,
748                    }));
749                    state.add_element(element.pop_push(Rule {
750                        kind: self.kind,
751                        state: 3usize,
752                    }));
753                    state.add_element(element.pop_push(Rule {
754                        kind: self.kind,
755                        state: 4usize,
756                    }));
757                    state.add_element_checked(
758                        element.pop_push(Rule {
759                            kind: self.kind,
760                            state: 5usize,
761                        }),
762                        SyntaxKind::JsonNumber,
763                    );
764                    state.add_element_checked(
765                        element.pop_push(Rule {
766                            kind: self.kind,
767                            state: 6usize,
768                        }),
769                        SyntaxKind::TrueLit,
770                    );
771                    state.add_element_checked(
772                        element.pop_push(Rule {
773                            kind: self.kind,
774                            state: 7usize,
775                        }),
776                        SyntaxKind::FalseLit,
777                    );
778                    state.add_element_checked(
779                        element.pop_push(Rule {
780                            kind: self.kind,
781                            state: 8usize,
782                        }),
783                        SyntaxKind::NullLit,
784                    );
785                }
786                (SyntaxKind::JsonValue, 2usize) => {
787                    state.add_element_checked(
788                        element
789                            .pop_push(Rule {
790                                kind: self.kind,
791                                state: 0usize,
792                            })
793                            .push(Rule {
794                                kind: SyntaxKind::JsonObject,
795                                state: 4usize,
796                            }),
797                        SyntaxKind::JsonObject,
798                    );
799                }
800                (SyntaxKind::JsonValue, 3usize) => {
801                    state.add_element_checked(
802                        element
803                            .pop_push(Rule {
804                                kind: self.kind,
805                                state: 0usize,
806                            })
807                            .push(Rule {
808                                kind: SyntaxKind::JsonArray,
809                                state: 4usize,
810                            }),
811                        SyntaxKind::JsonArray,
812                    );
813                }
814                (SyntaxKind::JsonValue, 4usize) => {
815                    state.add_element_checked(
816                        element
817                            .pop_push(Rule {
818                                kind: self.kind,
819                                state: 0usize,
820                            })
821                            .push(Rule {
822                                kind: SyntaxKind::JsonString,
823                                state: 1usize,
824                            }),
825                        SyntaxKind::JsonString,
826                    );
827                }
828                (SyntaxKind::JsonValue, 5usize) => {
829                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::JsonNumber);
830                    state.add_element(matched.pop_push(Rule {
831                        kind: self.kind,
832                        state: 0usize,
833                    }));
834                    if let Some(fb) = fb {
835                        state.add_element(fb.pop_push(Rule {
836                            kind: self.kind,
837                            state: 0usize,
838                        }));
839                    }
840                }
841                (SyntaxKind::JsonValue, 6usize) => {
842                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::TrueLit);
843                    state.add_element(matched.pop_push(Rule {
844                        kind: self.kind,
845                        state: 0usize,
846                    }));
847                    if let Some(fb) = fb {
848                        state.add_element(fb.pop_push(Rule {
849                            kind: self.kind,
850                            state: 0usize,
851                        }));
852                    }
853                }
854                (SyntaxKind::JsonValue, 7usize) => {
855                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::FalseLit);
856                    state.add_element(matched.pop_push(Rule {
857                        kind: self.kind,
858                        state: 0usize,
859                    }));
860                    if let Some(fb) = fb {
861                        state.add_element(fb.pop_push(Rule {
862                            kind: self.kind,
863                            state: 0usize,
864                        }));
865                    }
866                }
867                (SyntaxKind::JsonValue, 8usize) => {
868                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::NullLit);
869                    state.add_element(matched.pop_push(Rule {
870                        kind: self.kind,
871                        state: 0usize,
872                    }));
873                    if let Some(fb) = fb {
874                        state.add_element(fb.pop_push(Rule {
875                            kind: self.kind,
876                            state: 0usize,
877                        }));
878                    }
879                }
880                (SyntaxKind::ValueList, 0usize) => {
881                    if let Some(parent) = element.pop() {
882                        state.add_element(parent);
883                    }
884                }
885                (SyntaxKind::ValueList, 1usize) => {
886                    state.add_element(element.pop_push(Rule {
887                        kind: self.kind,
888                        state: 3usize,
889                    }));
890                    state.add_element(element.pop_push(Rule {
891                        kind: self.kind,
892                        state: 0usize,
893                    }));
894                }
895                (SyntaxKind::ValueList, 2usize) => {
896                    state.add_element_checked(
897                        element
898                            .pop_push(Rule {
899                                kind: self.kind,
900                                state: 1usize,
901                            })
902                            .push(Rule {
903                                kind: SyntaxKind::JsonValue,
904                                state: 1usize,
905                            }),
906                        SyntaxKind::JsonValue,
907                    );
908                }
909                (SyntaxKind::ValueList, 3usize) => {
910                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::Comma);
911                    state.add_element(matched.pop_push(Rule {
912                        kind: self.kind,
913                        state: 2usize,
914                    }));
915                    if let Some(fb) = fb {
916                        state.add_element(fb.pop_push(Rule {
917                            kind: self.kind,
918                            state: 2usize,
919                        }));
920                    }
921                }
922                (SyntaxKind::ValueList, 4usize) => {
923                    state.add_element(element.pop_push(Rule {
924                        kind: self.kind,
925                        state: 2usize,
926                    }));
927                }
928                (SyntaxKind::JsonString, 0usize) => {
929                    if let Some(parent) = element.pop() {
930                        state.add_element(parent);
931                    }
932                }
933                (SyntaxKind::JsonString, 1usize) => {
934                    let (matched, fb) = state.expect_as_inline(element, SyntaxKind::StringToken);
935                    state.add_element(matched.pop_push(Rule {
936                        kind: self.kind,
937                        state: 0usize,
938                    }));
939                    if let Some(fb) = fb {
940                        state.add_element(fb.pop_push(Rule {
941                            kind: self.kind,
942                            state: 0usize,
943                        }));
944                    }
945                }
946                (SyntaxKind::Comma, _) => {
947                    let added = state.expect_as(element, SyntaxKind::Comma);
948                    if let Some(parent) = added.pop() {
949                        state.add_element(parent);
950                    }
951                }
952                (SyntaxKind::Colon, _) => {
953                    let added = state.expect_as(element, SyntaxKind::Colon);
954                    if let Some(parent) = added.pop() {
955                        state.add_element(parent);
956                    }
957                }
958                (SyntaxKind::SqOpen, _) => {
959                    let added = state.expect_as(element, SyntaxKind::SqOpen);
960                    if let Some(parent) = added.pop() {
961                        state.add_element(parent);
962                    }
963                }
964                (SyntaxKind::SqClose, _) => {
965                    let added = state.expect_as(element, SyntaxKind::SqClose);
966                    if let Some(parent) = added.pop() {
967                        state.add_element(parent);
968                    }
969                }
970                (SyntaxKind::FalseLit, _) => {
971                    let added = state.expect_as(element, SyntaxKind::FalseLit);
972                    if let Some(parent) = added.pop() {
973                        state.add_element(parent);
974                    }
975                }
976                (SyntaxKind::NullLit, _) => {
977                    let added = state.expect_as(element, SyntaxKind::NullLit);
978                    if let Some(parent) = added.pop() {
979                        state.add_element(parent);
980                    }
981                }
982                (SyntaxKind::TrueLit, _) => {
983                    let added = state.expect_as(element, SyntaxKind::TrueLit);
984                    if let Some(parent) = added.pop() {
985                        state.add_element(parent);
986                    }
987                }
988                (SyntaxKind::CurlyOpen, _) => {
989                    let added = state.expect_as(element, SyntaxKind::CurlyOpen);
990                    if let Some(parent) = added.pop() {
991                        state.add_element(parent);
992                    }
993                }
994                (SyntaxKind::CurlyClose, _) => {
995                    let added = state.expect_as(element, SyntaxKind::CurlyClose);
996                    if let Some(parent) = added.pop() {
997                        state.add_element(parent);
998                    }
999                }
1000                (SyntaxKind::JsonNumber, _) => {
1001                    let added = state.expect_as(element, SyntaxKind::JsonNumber);
1002                    if let Some(parent) = added.pop() {
1003                        state.add_element(parent);
1004                    }
1005                }
1006                (SyntaxKind::StringToken, _) => {
1007                    let added = state.expect_as(element, SyntaxKind::StringToken);
1008                    if let Some(parent) = added.pop() {
1009                        state.add_element(parent);
1010                    }
1011                }
1012                _ => panic!("Aaaah unexpected state {:?}", self),
1013            }
1014        }
1015        fn at(&self) -> usize {
1016            self.state
1017        }
1018        fn element_kind(&self) -> SyntaxKind {
1019            self.kind
1020        }
1021        fn state_dist(&self, terminal: &SyntaxKind) -> isize {
1022            state_dist(self.kind, self.state, *terminal)
1023        }
1024    }
1025}
1026pub use definitions::*;
1027impl TokenTrait for SyntaxKind {
1028    const ERROR: Self = SyntaxKind::Error;
1029    const ROOT: Self = SyntaxKind::ROOT;
1030    fn branch(&self) -> u32 {
1031        *self as u32
1032    }
1033    fn skips(&self) -> bool {
1034        match self {
1035            SyntaxKind::WhiteSpace => true,
1036            SyntaxKind::Error => true,
1037            SyntaxKind::Comment => true,
1038            _ => false,
1039        }
1040    }
1041    fn starting_tokens(&self) -> &'static [SyntaxKind] {
1042        &[]
1043    }
1044    fn min_error_for_token(&self, tok: &SyntaxKind) -> isize {
1045        min_error_for_token(*self, *tok)
1046    }
1047    fn ending_tokens(&self) -> &'static [SyntaxKind] {
1048        &[]
1049    }
1050    fn max_error_value(&self) -> isize {
1051        match self {
1052            SyntaxKind::Comma => 2isize,
1053            SyntaxKind::Colon => 3isize,
1054            SyntaxKind::SqOpen => 4isize,
1055            SyntaxKind::SqClose => 4isize,
1056            SyntaxKind::CurlyOpen => 2isize,
1057            SyntaxKind::CurlyClose => 2isize,
1058            _ => 1isize,
1059        }
1060    }
1061    fn bracket_delta(&self) -> i8 {
1062        match self {
1063            SyntaxKind::CurlyOpen => 1,
1064            SyntaxKind::SqOpen => 1,
1065            SyntaxKind::CurlyClose => -1,
1066            SyntaxKind::SqClose => -1,
1067            _ => 0,
1068        }
1069    }
1070    fn min_completion_cost(&self) -> isize {
1071        match self {
1072            SyntaxKind::JsonArray => 8isize,
1073            SyntaxKind::JsonObject => 4isize,
1074            SyntaxKind::Member => 5isize,
1075            SyntaxKind::MemberList => 5isize,
1076            _ => Self::max_error_value(self),
1077        }
1078    }
1079    fn deletion_cost(&self) -> isize {
1080        match self {
1081            _ => Self::max_error_value(self) * 5,
1082        }
1083    }
1084}
1085pub mod format {
1086    use super::{SyntaxKind, SyntaxNode};
1087    use crate::format::Doc;
1088    use crate::TokenTrait;
1089    use rowan::NodeOrToken;
1090    #[derive(Default)]
1091    struct Hints {
1092        space: bool,
1093        line: bool,
1094        hardline: bool,
1095        blankline: bool,
1096        indent: bool,
1097        dedent: bool,
1098    }
1099    impl Hints {
1100        fn to_docs(&self) -> Vec<Doc> {
1101            let mut v = Vec::new();
1102            if self.indent {
1103                v.push(Doc::nil());
1104            }
1105            if self.dedent {
1106                v.push(Doc::nil());
1107            }
1108            if self.blankline {
1109                v.push(Doc::HardLine);
1110                v.push(Doc::HardLine);
1111            } else if self.hardline {
1112                v.push(Doc::HardLine);
1113            } else if self.line {
1114                v.push(Doc::Line);
1115            } else if self.space {
1116                v.push(Doc::text(" "));
1117            }
1118            v
1119        }
1120    }
1121    fn format_hints(parent: SyntaxKind, token: SyntaxKind) -> (Hints, Hints) {
1122        match (parent, token) {
1123            (_, SyntaxKind::CurlyOpen) => (
1124                Hints {
1125                    space: false,
1126                    line: false,
1127                    hardline: false,
1128                    blankline: false,
1129                    indent: false,
1130                    dedent: false,
1131                },
1132                Hints {
1133                    space: false,
1134                    line: true,
1135                    hardline: false,
1136                    blankline: false,
1137                    indent: true,
1138                    dedent: false,
1139                },
1140            ),
1141            (_, SyntaxKind::CurlyClose) => (
1142                Hints {
1143                    space: false,
1144                    line: true,
1145                    hardline: false,
1146                    blankline: false,
1147                    indent: false,
1148                    dedent: true,
1149                },
1150                Hints {
1151                    space: false,
1152                    line: false,
1153                    hardline: false,
1154                    blankline: false,
1155                    indent: false,
1156                    dedent: false,
1157                },
1158            ),
1159            (_, SyntaxKind::SqOpen) => (
1160                Hints {
1161                    space: false,
1162                    line: false,
1163                    hardline: false,
1164                    blankline: false,
1165                    indent: false,
1166                    dedent: false,
1167                },
1168                Hints {
1169                    space: false,
1170                    line: true,
1171                    hardline: false,
1172                    blankline: false,
1173                    indent: true,
1174                    dedent: false,
1175                },
1176            ),
1177            (_, SyntaxKind::SqClose) => (
1178                Hints {
1179                    space: false,
1180                    line: true,
1181                    hardline: false,
1182                    blankline: false,
1183                    indent: false,
1184                    dedent: true,
1185                },
1186                Hints {
1187                    space: false,
1188                    line: false,
1189                    hardline: false,
1190                    blankline: false,
1191                    indent: false,
1192                    dedent: false,
1193                },
1194            ),
1195            (_, SyntaxKind::Comma) => (
1196                Hints {
1197                    space: false,
1198                    line: false,
1199                    hardline: false,
1200                    blankline: false,
1201                    indent: false,
1202                    dedent: false,
1203                },
1204                Hints {
1205                    space: false,
1206                    line: true,
1207                    hardline: false,
1208                    blankline: false,
1209                    indent: false,
1210                    dedent: false,
1211                },
1212            ),
1213            (_, SyntaxKind::Colon) => (
1214                Hints {
1215                    space: false,
1216                    line: false,
1217                    hardline: false,
1218                    blankline: false,
1219                    indent: false,
1220                    dedent: false,
1221                },
1222                Hints {
1223                    space: true,
1224                    line: false,
1225                    hardline: false,
1226                    blankline: false,
1227                    indent: false,
1228                    dedent: false,
1229                },
1230            ),
1231            _ => (Hints::default(), Hints::default()),
1232        }
1233    }
1234    fn is_group(kind: SyntaxKind) -> bool {
1235        matches!(kind, SyntaxKind::JsonObject | SyntaxKind::JsonArray)
1236    }
1237    pub fn to_doc(node: &SyntaxNode) -> Doc {
1238        let mut parts: Vec<Vec<Doc>> = vec![vec![]];
1239        for child in node.children_with_tokens() {
1240            match child {
1241                NodeOrToken::Token(t) => {
1242                    if t.kind() == SyntaxKind::WhiteSpace {
1243                        continue;
1244                    }
1245                    if t.kind() == SyntaxKind::Comment {
1246                        parts
1247                            .last_mut()
1248                            .unwrap()
1249                            .push(Doc::text(t.text().to_string()));
1250                        continue;
1251                    }
1252                    let (before, after) = format_hints(node.kind(), t.kind());
1253                    if before.dedent && parts.len() > 1 {
1254                        let nested = parts.pop().unwrap_or_default();
1255                        let indent_doc = Doc::nest(2, Doc::concat(nested));
1256                        parts.last_mut().unwrap().push(indent_doc);
1257                    }
1258                    parts.last_mut().unwrap().extend(
1259                        before
1260                            .to_docs()
1261                            .into_iter()
1262                            .filter(|d| !matches!(d, Doc::Nil)),
1263                    );
1264                    parts
1265                        .last_mut()
1266                        .unwrap()
1267                        .push(Doc::text(t.text().to_string()));
1268                    let after_line: Vec<Doc> = after
1269                        .to_docs()
1270                        .into_iter()
1271                        .filter(|d| !matches!(d, Doc::Nil))
1272                        .collect();
1273                    if after.indent {
1274                        parts.push(after_line);
1275                    } else {
1276                        parts.last_mut().unwrap().extend(after_line);
1277                    }
1278                }
1279                NodeOrToken::Node(n) => {
1280                    if n.kind() == SyntaxKind::ERROR {
1281                        parts
1282                            .last_mut()
1283                            .unwrap()
1284                            .push(Doc::text(n.text().to_string()));
1285                        continue;
1286                    }
1287                    let is_terminal_wrapper = {
1288                        let mut it = n.children_with_tokens().filter(|c| match c {
1289                            NodeOrToken::Token(t) => t.kind() != SyntaxKind::WhiteSpace,
1290                            NodeOrToken::Node(_) => true,
1291                        });
1292                        matches!(it.next(), Some(NodeOrToken::Token(_))) && it.next().is_none()
1293                    };
1294                    if is_terminal_wrapper {
1295                        let token_text = n.text().to_string();
1296                        let (before, after) = format_hints(node.kind(), n.kind());
1297                        if before.dedent && parts.len() > 1 {
1298                            let nested = parts.pop().unwrap_or_default();
1299                            let indent_doc = Doc::nest(2, Doc::concat(nested));
1300                            parts.last_mut().unwrap().push(indent_doc);
1301                        }
1302                        parts.last_mut().unwrap().extend(
1303                            before
1304                                .to_docs()
1305                                .into_iter()
1306                                .filter(|d| !matches!(d, Doc::Nil)),
1307                        );
1308                        parts.last_mut().unwrap().push(Doc::text(token_text));
1309                        let after_line: Vec<Doc> = after
1310                            .to_docs()
1311                            .into_iter()
1312                            .filter(|d| !matches!(d, Doc::Nil))
1313                            .collect();
1314                        if after.indent {
1315                            parts.push(after_line);
1316                        } else {
1317                            parts.last_mut().unwrap().extend(after_line);
1318                        }
1319                    } else {
1320                        let (before, after) = format_hints(node.kind(), n.kind());
1321                        if before.dedent && parts.len() > 1 {
1322                            let nested = parts.pop().unwrap_or_default();
1323                            let indent_doc = Doc::nest(2, Doc::concat(nested));
1324                            parts.last_mut().unwrap().push(indent_doc);
1325                        }
1326                        parts.last_mut().unwrap().extend(
1327                            before
1328                                .to_docs()
1329                                .into_iter()
1330                                .filter(|d| !matches!(d, Doc::Nil)),
1331                        );
1332                        let child_doc = to_doc(&n);
1333                        let child_doc = if is_group(n.kind()) {
1334                            Doc::group(child_doc)
1335                        } else {
1336                            child_doc
1337                        };
1338                        parts.last_mut().unwrap().push(child_doc);
1339                        let after_line: Vec<Doc> = after
1340                            .to_docs()
1341                            .into_iter()
1342                            .filter(|d| !matches!(d, Doc::Nil))
1343                            .collect();
1344                        if after.indent {
1345                            parts.push(after_line);
1346                        } else {
1347                            parts.last_mut().unwrap().extend(after_line);
1348                        }
1349                    }
1350                }
1351            }
1352        }
1353        while parts.len() > 1 {
1354            let nested = parts.pop().unwrap();
1355            parts
1356                .last_mut()
1357                .unwrap()
1358                .push(Doc::nest(2, Doc::concat(nested)));
1359        }
1360        Doc::concat(parts.pop().unwrap_or_default())
1361    }
1362    pub fn format(node: &SyntaxNode, width: usize) -> String {
1363        let doc = to_doc(node);
1364        let s = crate::format::render(&doc, width);
1365        let s = s.trim_start_matches('\n').trim_end_matches('\n');
1366        format!("{s}\n")
1367    }
1368}
rdf_parsers/jsonld/parser.rs

rdf_parsers/jsonld/
parser.rs
