1#![allow(unused_variables)]
4use super::node_kind::{NodeKind, NonTerminalKind, TerminalKind};
5use super::tree::{
6 CstFacade, CstNodeId, NonTerminalHandle, RecursiveView, TerminalHandle, ViewConstructionError,
7};
8use super::visitor::BuiltinTerminalVisitor;
9use crate::CstConstructError;
10#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
11pub struct ArrayHandle(pub(crate) super::tree::CstNodeId);
12impl NonTerminalHandle for ArrayHandle {
13 type View = ArrayView;
14 fn node_id(&self) -> CstNodeId {
15 self.0
16 }
17 fn new_with_visit<F: CstFacade, E>(
18 index: CstNodeId,
19 tree: &F,
20 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
21 ) -> Result<Self, CstConstructError<E>> {
22 tree.collect_nodes(
23 index,
24 [NodeKind::NonTerminal(NonTerminalKind::Array)],
25 |[index], visit| Ok((Self(index), visit)),
26 visit_ignored,
27 )
28 }
29 fn kind(&self) -> NonTerminalKind {
30 NonTerminalKind::Array
31 }
32 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
33 &self,
34 tree: &F,
35 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
36 visit_ignored: &'v mut V,
37 ) -> Result<O, CstConstructError<E>> {
38 tree.collect_nodes(
39 self.0,
40 [
41 NodeKind::NonTerminal(NonTerminalKind::ArrayBegin),
42 NodeKind::NonTerminal(NonTerminalKind::ArrayOpt),
43 NodeKind::NonTerminal(NonTerminalKind::ArrayEnd),
44 ],
45 |[array_begin, array_opt, array_end], visit_ignored| {
46 Ok(visit(
47 ArrayView {
48 array_begin: ArrayBeginHandle(array_begin),
49 array_opt: ArrayOptHandle(array_opt),
50 array_end: ArrayEndHandle(array_end),
51 },
52 visit_ignored,
53 ))
54 },
55 visit_ignored,
56 )
57 }
58}
59#[derive(Debug, Clone, Copy, PartialEq, Eq)]
60pub struct ArrayView {
61 pub array_begin: ArrayBeginHandle,
62 pub array_opt: ArrayOptHandle,
63 pub array_end: ArrayEndHandle,
64}
65impl ArrayView {}
66#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
67pub struct ArrayBeginHandle(pub(crate) super::tree::CstNodeId);
68impl NonTerminalHandle for ArrayBeginHandle {
69 type View = ArrayBeginView;
70 fn node_id(&self) -> CstNodeId {
71 self.0
72 }
73 fn new_with_visit<F: CstFacade, E>(
74 index: CstNodeId,
75 tree: &F,
76 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
77 ) -> Result<Self, CstConstructError<E>> {
78 tree.collect_nodes(
79 index,
80 [NodeKind::NonTerminal(NonTerminalKind::ArrayBegin)],
81 |[index], visit| Ok((Self(index), visit)),
82 visit_ignored,
83 )
84 }
85 fn kind(&self) -> NonTerminalKind {
86 NonTerminalKind::ArrayBegin
87 }
88 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
89 &self,
90 tree: &F,
91 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
92 visit_ignored: &'v mut V,
93 ) -> Result<O, CstConstructError<E>> {
94 tree.collect_nodes(
95 self.0,
96 [NodeKind::Terminal(TerminalKind::LBracket)],
97 |[l_bracket], visit_ignored| {
98 Ok(visit(
99 ArrayBeginView {
100 l_bracket: LBracket(l_bracket),
101 },
102 visit_ignored,
103 ))
104 },
105 visit_ignored,
106 )
107 }
108}
109#[derive(Debug, Clone, Copy, PartialEq, Eq)]
110pub struct ArrayBeginView {
111 pub l_bracket: LBracket,
112}
113impl ArrayBeginView {}
114#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
115pub struct ArrayElementsHandle(pub(crate) super::tree::CstNodeId);
116impl NonTerminalHandle for ArrayElementsHandle {
117 type View = ArrayElementsView;
118 fn node_id(&self) -> CstNodeId {
119 self.0
120 }
121 fn new_with_visit<F: CstFacade, E>(
122 index: CstNodeId,
123 tree: &F,
124 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
125 ) -> Result<Self, CstConstructError<E>> {
126 tree.collect_nodes(
127 index,
128 [NodeKind::NonTerminal(NonTerminalKind::ArrayElements)],
129 |[index], visit| Ok((Self(index), visit)),
130 visit_ignored,
131 )
132 }
133 fn kind(&self) -> NonTerminalKind {
134 NonTerminalKind::ArrayElements
135 }
136 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
137 &self,
138 tree: &F,
139 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
140 visit_ignored: &'v mut V,
141 ) -> Result<O, CstConstructError<E>> {
142 tree.collect_nodes(
143 self.0,
144 [
145 NodeKind::NonTerminal(NonTerminalKind::Value),
146 NodeKind::NonTerminal(NonTerminalKind::ArrayElementsOpt),
147 ],
148 |[value, array_elements_opt], visit_ignored| {
149 Ok(visit(
150 ArrayElementsView {
151 value: ValueHandle(value),
152 array_elements_opt: ArrayElementsOptHandle(array_elements_opt),
153 },
154 visit_ignored,
155 ))
156 },
157 visit_ignored,
158 )
159 }
160}
161#[derive(Debug, Clone, Copy, PartialEq, Eq)]
162pub struct ArrayElementsView {
163 pub value: ValueHandle,
164 pub array_elements_opt: ArrayElementsOptHandle,
165}
166impl ArrayElementsView {}
167#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
168pub struct ArrayElementsOptHandle(pub(crate) super::tree::CstNodeId);
169impl NonTerminalHandle for ArrayElementsOptHandle {
170 type View = Option<ArrayElementsTailHandle>;
171 fn node_id(&self) -> CstNodeId {
172 self.0
173 }
174 fn new_with_visit<F: CstFacade, E>(
175 index: CstNodeId,
176 tree: &F,
177 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
178 ) -> Result<Self, CstConstructError<E>> {
179 tree.collect_nodes(
180 index,
181 [NodeKind::NonTerminal(NonTerminalKind::ArrayElementsOpt)],
182 |[index], visit| Ok((Self(index), visit)),
183 visit_ignored,
184 )
185 }
186 fn kind(&self) -> NonTerminalKind {
187 NonTerminalKind::ArrayElementsOpt
188 }
189 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
190 &self,
191 tree: &F,
192 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
193 visit_ignored: &'v mut V,
194 ) -> Result<O, CstConstructError<E>> {
195 if tree.has_no_children(self.0) {
196 return Ok(visit(None, visit_ignored).0);
197 }
198 Ok(visit(
199 Some(ArrayElementsTailHandle::new_with_visit(
200 self.0,
201 tree,
202 visit_ignored,
203 )?),
204 visit_ignored,
205 )
206 .0)
207 }
208}
209#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
210pub struct ArrayElementsTailHandle(pub(crate) super::tree::CstNodeId);
211impl NonTerminalHandle for ArrayElementsTailHandle {
212 type View = ArrayElementsTailView;
213 fn node_id(&self) -> CstNodeId {
214 self.0
215 }
216 fn new_with_visit<F: CstFacade, E>(
217 index: CstNodeId,
218 tree: &F,
219 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
220 ) -> Result<Self, CstConstructError<E>> {
221 tree.collect_nodes(
222 index,
223 [NodeKind::NonTerminal(NonTerminalKind::ArrayElementsTail)],
224 |[index], visit| Ok((Self(index), visit)),
225 visit_ignored,
226 )
227 }
228 fn kind(&self) -> NonTerminalKind {
229 NonTerminalKind::ArrayElementsTail
230 }
231 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
232 &self,
233 tree: &F,
234 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
235 visit_ignored: &'v mut V,
236 ) -> Result<O, CstConstructError<E>> {
237 tree.collect_nodes(
238 self.0,
239 [
240 NodeKind::NonTerminal(NonTerminalKind::Comma),
241 NodeKind::NonTerminal(NonTerminalKind::ArrayElementsTailOpt),
242 ],
243 |[comma, array_elements_tail_opt], visit_ignored| {
244 Ok(visit(
245 ArrayElementsTailView {
246 comma: CommaHandle(comma),
247 array_elements_tail_opt: ArrayElementsTailOptHandle(
248 array_elements_tail_opt,
249 ),
250 },
251 visit_ignored,
252 ))
253 },
254 visit_ignored,
255 )
256 }
257}
258#[derive(Debug, Clone, Copy, PartialEq, Eq)]
259pub struct ArrayElementsTailView {
260 pub comma: CommaHandle,
261 pub array_elements_tail_opt: ArrayElementsTailOptHandle,
262}
263impl ArrayElementsTailView {}
264#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
265pub struct ArrayElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
266impl NonTerminalHandle for ArrayElementsTailOptHandle {
267 type View = Option<ArrayElementsHandle>;
268 fn node_id(&self) -> CstNodeId {
269 self.0
270 }
271 fn new_with_visit<F: CstFacade, E>(
272 index: CstNodeId,
273 tree: &F,
274 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
275 ) -> Result<Self, CstConstructError<E>> {
276 tree.collect_nodes(
277 index,
278 [NodeKind::NonTerminal(NonTerminalKind::ArrayElementsTailOpt)],
279 |[index], visit| Ok((Self(index), visit)),
280 visit_ignored,
281 )
282 }
283 fn kind(&self) -> NonTerminalKind {
284 NonTerminalKind::ArrayElementsTailOpt
285 }
286 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
287 &self,
288 tree: &F,
289 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
290 visit_ignored: &'v mut V,
291 ) -> Result<O, CstConstructError<E>> {
292 if tree.has_no_children(self.0) {
293 return Ok(visit(None, visit_ignored).0);
294 }
295 Ok(visit(
296 Some(ArrayElementsHandle::new_with_visit(
297 self.0,
298 tree,
299 visit_ignored,
300 )?),
301 visit_ignored,
302 )
303 .0)
304 }
305}
306#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
307pub struct ArrayEndHandle(pub(crate) super::tree::CstNodeId);
308impl NonTerminalHandle for ArrayEndHandle {
309 type View = ArrayEndView;
310 fn node_id(&self) -> CstNodeId {
311 self.0
312 }
313 fn new_with_visit<F: CstFacade, E>(
314 index: CstNodeId,
315 tree: &F,
316 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
317 ) -> Result<Self, CstConstructError<E>> {
318 tree.collect_nodes(
319 index,
320 [NodeKind::NonTerminal(NonTerminalKind::ArrayEnd)],
321 |[index], visit| Ok((Self(index), visit)),
322 visit_ignored,
323 )
324 }
325 fn kind(&self) -> NonTerminalKind {
326 NonTerminalKind::ArrayEnd
327 }
328 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
329 &self,
330 tree: &F,
331 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
332 visit_ignored: &'v mut V,
333 ) -> Result<O, CstConstructError<E>> {
334 tree.collect_nodes(
335 self.0,
336 [NodeKind::Terminal(TerminalKind::RBracket)],
337 |[r_bracket], visit_ignored| {
338 Ok(visit(
339 ArrayEndView {
340 r_bracket: RBracket(r_bracket),
341 },
342 visit_ignored,
343 ))
344 },
345 visit_ignored,
346 )
347 }
348}
349#[derive(Debug, Clone, Copy, PartialEq, Eq)]
350pub struct ArrayEndView {
351 pub r_bracket: RBracket,
352}
353impl ArrayEndView {}
354#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
355pub struct ArrayMarkerHandle(pub(crate) super::tree::CstNodeId);
356impl NonTerminalHandle for ArrayMarkerHandle {
357 type View = ArrayMarkerView;
358 fn node_id(&self) -> CstNodeId {
359 self.0
360 }
361 fn new_with_visit<F: CstFacade, E>(
362 index: CstNodeId,
363 tree: &F,
364 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
365 ) -> Result<Self, CstConstructError<E>> {
366 tree.collect_nodes(
367 index,
368 [NodeKind::NonTerminal(NonTerminalKind::ArrayMarker)],
369 |[index], visit| Ok((Self(index), visit)),
370 visit_ignored,
371 )
372 }
373 fn kind(&self) -> NonTerminalKind {
374 NonTerminalKind::ArrayMarker
375 }
376 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
377 &self,
378 tree: &F,
379 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
380 visit_ignored: &'v mut V,
381 ) -> Result<O, CstConstructError<E>> {
382 tree.collect_nodes(
383 self.0,
384 [
385 NodeKind::NonTerminal(NonTerminalKind::ArrayBegin),
386 NodeKind::NonTerminal(NonTerminalKind::ArrayMarkerOpt),
387 NodeKind::NonTerminal(NonTerminalKind::ArrayEnd),
388 ],
389 |[array_begin, array_marker_opt, array_end], visit_ignored| {
390 Ok(visit(
391 ArrayMarkerView {
392 array_begin: ArrayBeginHandle(array_begin),
393 array_marker_opt: ArrayMarkerOptHandle(array_marker_opt),
394 array_end: ArrayEndHandle(array_end),
395 },
396 visit_ignored,
397 ))
398 },
399 visit_ignored,
400 )
401 }
402}
403#[derive(Debug, Clone, Copy, PartialEq, Eq)]
404pub struct ArrayMarkerView {
405 pub array_begin: ArrayBeginHandle,
406 pub array_marker_opt: ArrayMarkerOptHandle,
407 pub array_end: ArrayEndHandle,
408}
409impl ArrayMarkerView {}
410#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
411pub struct ArrayMarkerOptHandle(pub(crate) super::tree::CstNodeId);
412impl NonTerminalHandle for ArrayMarkerOptHandle {
413 type View = Option<IntegerHandle>;
414 fn node_id(&self) -> CstNodeId {
415 self.0
416 }
417 fn new_with_visit<F: CstFacade, E>(
418 index: CstNodeId,
419 tree: &F,
420 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
421 ) -> Result<Self, CstConstructError<E>> {
422 tree.collect_nodes(
423 index,
424 [NodeKind::NonTerminal(NonTerminalKind::ArrayMarkerOpt)],
425 |[index], visit| Ok((Self(index), visit)),
426 visit_ignored,
427 )
428 }
429 fn kind(&self) -> NonTerminalKind {
430 NonTerminalKind::ArrayMarkerOpt
431 }
432 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
433 &self,
434 tree: &F,
435 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
436 visit_ignored: &'v mut V,
437 ) -> Result<O, CstConstructError<E>> {
438 if tree.has_no_children(self.0) {
439 return Ok(visit(None, visit_ignored).0);
440 }
441 Ok(visit(
442 Some(IntegerHandle::new_with_visit(self.0, tree, visit_ignored)?),
443 visit_ignored,
444 )
445 .0)
446 }
447}
448#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
449pub struct ArrayOptHandle(pub(crate) super::tree::CstNodeId);
450impl NonTerminalHandle for ArrayOptHandle {
451 type View = Option<ArrayElementsHandle>;
452 fn node_id(&self) -> CstNodeId {
453 self.0
454 }
455 fn new_with_visit<F: CstFacade, E>(
456 index: CstNodeId,
457 tree: &F,
458 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
459 ) -> Result<Self, CstConstructError<E>> {
460 tree.collect_nodes(
461 index,
462 [NodeKind::NonTerminal(NonTerminalKind::ArrayOpt)],
463 |[index], visit| Ok((Self(index), visit)),
464 visit_ignored,
465 )
466 }
467 fn kind(&self) -> NonTerminalKind {
468 NonTerminalKind::ArrayOpt
469 }
470 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
471 &self,
472 tree: &F,
473 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
474 visit_ignored: &'v mut V,
475 ) -> Result<O, CstConstructError<E>> {
476 if tree.has_no_children(self.0) {
477 return Ok(visit(None, visit_ignored).0);
478 }
479 Ok(visit(
480 Some(ArrayElementsHandle::new_with_visit(
481 self.0,
482 tree,
483 visit_ignored,
484 )?),
485 visit_ignored,
486 )
487 .0)
488 }
489}
490#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
491pub struct AtHandle(pub(crate) super::tree::CstNodeId);
492impl NonTerminalHandle for AtHandle {
493 type View = AtView;
494 fn node_id(&self) -> CstNodeId {
495 self.0
496 }
497 fn new_with_visit<F: CstFacade, E>(
498 index: CstNodeId,
499 tree: &F,
500 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
501 ) -> Result<Self, CstConstructError<E>> {
502 tree.collect_nodes(
503 index,
504 [NodeKind::NonTerminal(NonTerminalKind::At)],
505 |[index], visit| Ok((Self(index), visit)),
506 visit_ignored,
507 )
508 }
509 fn kind(&self) -> NonTerminalKind {
510 NonTerminalKind::At
511 }
512 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
513 &self,
514 tree: &F,
515 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
516 visit_ignored: &'v mut V,
517 ) -> Result<O, CstConstructError<E>> {
518 tree.collect_nodes(
519 self.0,
520 [NodeKind::Terminal(TerminalKind::At)],
521 |[at], visit_ignored| Ok(visit(AtView { at: At(at) }, visit_ignored)),
522 visit_ignored,
523 )
524 }
525}
526#[derive(Debug, Clone, Copy, PartialEq, Eq)]
527pub struct AtView {
528 pub at: At,
529}
530impl AtView {}
531#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
532pub struct Backtick1Handle(pub(crate) super::tree::CstNodeId);
533impl NonTerminalHandle for Backtick1Handle {
534 type View = Backtick1View;
535 fn node_id(&self) -> CstNodeId {
536 self.0
537 }
538 fn new_with_visit<F: CstFacade, E>(
539 index: CstNodeId,
540 tree: &F,
541 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
542 ) -> Result<Self, CstConstructError<E>> {
543 tree.collect_nodes(
544 index,
545 [NodeKind::NonTerminal(NonTerminalKind::Backtick1)],
546 |[index], visit| Ok((Self(index), visit)),
547 visit_ignored,
548 )
549 }
550 fn kind(&self) -> NonTerminalKind {
551 NonTerminalKind::Backtick1
552 }
553 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
554 &self,
555 tree: &F,
556 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
557 visit_ignored: &'v mut V,
558 ) -> Result<O, CstConstructError<E>> {
559 tree.collect_nodes(
560 self.0,
561 [NodeKind::Terminal(TerminalKind::Backtick1)],
562 |[backtick_1], visit_ignored| {
563 Ok(visit(
564 Backtick1View {
565 backtick_1: Backtick1(backtick_1),
566 },
567 visit_ignored,
568 ))
569 },
570 visit_ignored,
571 )
572 }
573}
574#[derive(Debug, Clone, Copy, PartialEq, Eq)]
575pub struct Backtick1View {
576 pub backtick_1: Backtick1,
577}
578impl Backtick1View {}
579#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
580pub struct Backtick2Handle(pub(crate) super::tree::CstNodeId);
581impl NonTerminalHandle for Backtick2Handle {
582 type View = Backtick2View;
583 fn node_id(&self) -> CstNodeId {
584 self.0
585 }
586 fn new_with_visit<F: CstFacade, E>(
587 index: CstNodeId,
588 tree: &F,
589 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
590 ) -> Result<Self, CstConstructError<E>> {
591 tree.collect_nodes(
592 index,
593 [NodeKind::NonTerminal(NonTerminalKind::Backtick2)],
594 |[index], visit| Ok((Self(index), visit)),
595 visit_ignored,
596 )
597 }
598 fn kind(&self) -> NonTerminalKind {
599 NonTerminalKind::Backtick2
600 }
601 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
602 &self,
603 tree: &F,
604 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
605 visit_ignored: &'v mut V,
606 ) -> Result<O, CstConstructError<E>> {
607 tree.collect_nodes(
608 self.0,
609 [NodeKind::Terminal(TerminalKind::Backtick2)],
610 |[backtick_2], visit_ignored| {
611 Ok(visit(
612 Backtick2View {
613 backtick_2: Backtick2(backtick_2),
614 },
615 visit_ignored,
616 ))
617 },
618 visit_ignored,
619 )
620 }
621}
622#[derive(Debug, Clone, Copy, PartialEq, Eq)]
623pub struct Backtick2View {
624 pub backtick_2: Backtick2,
625}
626impl Backtick2View {}
627#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
628pub struct Backtick3Handle(pub(crate) super::tree::CstNodeId);
629impl NonTerminalHandle for Backtick3Handle {
630 type View = Backtick3View;
631 fn node_id(&self) -> CstNodeId {
632 self.0
633 }
634 fn new_with_visit<F: CstFacade, E>(
635 index: CstNodeId,
636 tree: &F,
637 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
638 ) -> Result<Self, CstConstructError<E>> {
639 tree.collect_nodes(
640 index,
641 [NodeKind::NonTerminal(NonTerminalKind::Backtick3)],
642 |[index], visit| Ok((Self(index), visit)),
643 visit_ignored,
644 )
645 }
646 fn kind(&self) -> NonTerminalKind {
647 NonTerminalKind::Backtick3
648 }
649 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
650 &self,
651 tree: &F,
652 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
653 visit_ignored: &'v mut V,
654 ) -> Result<O, CstConstructError<E>> {
655 tree.collect_nodes(
656 self.0,
657 [NodeKind::Terminal(TerminalKind::Backtick3)],
658 |[backtick_3], visit_ignored| {
659 Ok(visit(
660 Backtick3View {
661 backtick_3: Backtick3(backtick_3),
662 },
663 visit_ignored,
664 ))
665 },
666 visit_ignored,
667 )
668 }
669}
670#[derive(Debug, Clone, Copy, PartialEq, Eq)]
671pub struct Backtick3View {
672 pub backtick_3: Backtick3,
673}
674impl Backtick3View {}
675#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
676pub struct Backtick4Handle(pub(crate) super::tree::CstNodeId);
677impl NonTerminalHandle for Backtick4Handle {
678 type View = Backtick4View;
679 fn node_id(&self) -> CstNodeId {
680 self.0
681 }
682 fn new_with_visit<F: CstFacade, E>(
683 index: CstNodeId,
684 tree: &F,
685 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
686 ) -> Result<Self, CstConstructError<E>> {
687 tree.collect_nodes(
688 index,
689 [NodeKind::NonTerminal(NonTerminalKind::Backtick4)],
690 |[index], visit| Ok((Self(index), visit)),
691 visit_ignored,
692 )
693 }
694 fn kind(&self) -> NonTerminalKind {
695 NonTerminalKind::Backtick4
696 }
697 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
698 &self,
699 tree: &F,
700 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
701 visit_ignored: &'v mut V,
702 ) -> Result<O, CstConstructError<E>> {
703 tree.collect_nodes(
704 self.0,
705 [NodeKind::Terminal(TerminalKind::Backtick4)],
706 |[backtick_4], visit_ignored| {
707 Ok(visit(
708 Backtick4View {
709 backtick_4: Backtick4(backtick_4),
710 },
711 visit_ignored,
712 ))
713 },
714 visit_ignored,
715 )
716 }
717}
718#[derive(Debug, Clone, Copy, PartialEq, Eq)]
719pub struct Backtick4View {
720 pub backtick_4: Backtick4,
721}
722impl Backtick4View {}
723#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
724pub struct Backtick5Handle(pub(crate) super::tree::CstNodeId);
725impl NonTerminalHandle for Backtick5Handle {
726 type View = Backtick5View;
727 fn node_id(&self) -> CstNodeId {
728 self.0
729 }
730 fn new_with_visit<F: CstFacade, E>(
731 index: CstNodeId,
732 tree: &F,
733 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
734 ) -> Result<Self, CstConstructError<E>> {
735 tree.collect_nodes(
736 index,
737 [NodeKind::NonTerminal(NonTerminalKind::Backtick5)],
738 |[index], visit| Ok((Self(index), visit)),
739 visit_ignored,
740 )
741 }
742 fn kind(&self) -> NonTerminalKind {
743 NonTerminalKind::Backtick5
744 }
745 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
746 &self,
747 tree: &F,
748 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
749 visit_ignored: &'v mut V,
750 ) -> Result<O, CstConstructError<E>> {
751 tree.collect_nodes(
752 self.0,
753 [NodeKind::Terminal(TerminalKind::Backtick5)],
754 |[backtick_5], visit_ignored| {
755 Ok(visit(
756 Backtick5View {
757 backtick_5: Backtick5(backtick_5),
758 },
759 visit_ignored,
760 ))
761 },
762 visit_ignored,
763 )
764 }
765}
766#[derive(Debug, Clone, Copy, PartialEq, Eq)]
767pub struct Backtick5View {
768 pub backtick_5: Backtick5,
769}
770impl Backtick5View {}
771#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
772pub struct BeginHandle(pub(crate) super::tree::CstNodeId);
773impl NonTerminalHandle for BeginHandle {
774 type View = BeginView;
775 fn node_id(&self) -> CstNodeId {
776 self.0
777 }
778 fn new_with_visit<F: CstFacade, E>(
779 index: CstNodeId,
780 tree: &F,
781 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
782 ) -> Result<Self, CstConstructError<E>> {
783 tree.collect_nodes(
784 index,
785 [NodeKind::NonTerminal(NonTerminalKind::Begin)],
786 |[index], visit| Ok((Self(index), visit)),
787 visit_ignored,
788 )
789 }
790 fn kind(&self) -> NonTerminalKind {
791 NonTerminalKind::Begin
792 }
793 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
794 &self,
795 tree: &F,
796 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
797 visit_ignored: &'v mut V,
798 ) -> Result<O, CstConstructError<E>> {
799 tree.collect_nodes(
800 self.0,
801 [NodeKind::Terminal(TerminalKind::LBrace)],
802 |[l_brace], visit_ignored| {
803 Ok(visit(
804 BeginView {
805 l_brace: LBrace(l_brace),
806 },
807 visit_ignored,
808 ))
809 },
810 visit_ignored,
811 )
812 }
813}
814#[derive(Debug, Clone, Copy, PartialEq, Eq)]
815pub struct BeginView {
816 pub l_brace: LBrace,
817}
818impl BeginView {}
819#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
820pub struct BindHandle(pub(crate) super::tree::CstNodeId);
821impl NonTerminalHandle for BindHandle {
822 type View = BindView;
823 fn node_id(&self) -> CstNodeId {
824 self.0
825 }
826 fn new_with_visit<F: CstFacade, E>(
827 index: CstNodeId,
828 tree: &F,
829 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
830 ) -> Result<Self, CstConstructError<E>> {
831 tree.collect_nodes(
832 index,
833 [NodeKind::NonTerminal(NonTerminalKind::Bind)],
834 |[index], visit| Ok((Self(index), visit)),
835 visit_ignored,
836 )
837 }
838 fn kind(&self) -> NonTerminalKind {
839 NonTerminalKind::Bind
840 }
841 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
842 &self,
843 tree: &F,
844 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
845 visit_ignored: &'v mut V,
846 ) -> Result<O, CstConstructError<E>> {
847 tree.collect_nodes(
848 self.0,
849 [NodeKind::Terminal(TerminalKind::Bind)],
850 |[bind], visit_ignored| Ok(visit(BindView { bind: Bind(bind) }, visit_ignored)),
851 visit_ignored,
852 )
853 }
854}
855#[derive(Debug, Clone, Copy, PartialEq, Eq)]
856pub struct BindView {
857 pub bind: Bind,
858}
859impl BindView {}
860#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
861pub struct BindingHandle(pub(crate) super::tree::CstNodeId);
862impl NonTerminalHandle for BindingHandle {
863 type View = BindingView;
864 fn node_id(&self) -> CstNodeId {
865 self.0
866 }
867 fn new_with_visit<F: CstFacade, E>(
868 index: CstNodeId,
869 tree: &F,
870 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
871 ) -> Result<Self, CstConstructError<E>> {
872 tree.collect_nodes(
873 index,
874 [NodeKind::NonTerminal(NonTerminalKind::Binding)],
875 |[index], visit| Ok((Self(index), visit)),
876 visit_ignored,
877 )
878 }
879 fn kind(&self) -> NonTerminalKind {
880 NonTerminalKind::Binding
881 }
882 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
883 &self,
884 tree: &F,
885 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
886 visit_ignored: &'v mut V,
887 ) -> Result<O, CstConstructError<E>> {
888 tree.collect_nodes(
889 self.0,
890 [
891 NodeKind::NonTerminal(NonTerminalKind::Keys),
892 NodeKind::NonTerminal(NonTerminalKind::BindingRhs),
893 ],
894 |[keys, binding_rhs], visit_ignored| {
895 Ok(visit(
896 BindingView {
897 keys: KeysHandle(keys),
898 binding_rhs: BindingRhsHandle(binding_rhs),
899 },
900 visit_ignored,
901 ))
902 },
903 visit_ignored,
904 )
905 }
906}
907#[derive(Debug, Clone, Copy, PartialEq, Eq)]
908pub struct BindingView {
909 pub keys: KeysHandle,
910 pub binding_rhs: BindingRhsHandle,
911}
912impl BindingView {}
913#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
914pub struct BindingRhsHandle(pub(crate) super::tree::CstNodeId);
915impl NonTerminalHandle for BindingRhsHandle {
916 type View = BindingRhsView;
917 fn node_id(&self) -> CstNodeId {
918 self.0
919 }
920 fn new_with_visit<F: CstFacade, E>(
921 index: CstNodeId,
922 tree: &F,
923 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
924 ) -> Result<Self, CstConstructError<E>> {
925 tree.collect_nodes(
926 index,
927 [NodeKind::NonTerminal(NonTerminalKind::BindingRhs)],
928 |[index], visit| Ok((Self(index), visit)),
929 visit_ignored,
930 )
931 }
932 fn kind(&self) -> NonTerminalKind {
933 NonTerminalKind::BindingRhs
934 }
935 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
936 &self,
937 tree: &F,
938 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
939 visit_ignored: &'v mut V,
940 ) -> Result<O, CstConstructError<E>> {
941 let mut children = tree.children(self.0);
942 let Some(child) = children.next() else {
943 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
944 };
945 let Some(child_data) = tree.node_data(child) else {
946 return Err(ViewConstructionError::NodeIdNotFound { node: child });
947 };
948 let variant = match child_data.node_kind() {
949 NodeKind::NonTerminal(NonTerminalKind::ValueBinding) => {
950 BindingRhsView::ValueBinding(ValueBindingHandle(child))
951 }
952 NodeKind::NonTerminal(NonTerminalKind::SectionBinding) => {
953 BindingRhsView::SectionBinding(SectionBindingHandle(child))
954 }
955 NodeKind::NonTerminal(NonTerminalKind::TextBinding) => {
956 BindingRhsView::TextBinding(TextBindingHandle(child))
957 }
958 _ => {
959 return Err(ViewConstructionError::UnexpectedNode {
960 node: child,
961 data: child_data,
962 expected_kind: child_data.node_kind(),
963 });
964 }
965 };
966 let (result, _visit) = visit(variant, visit_ignored);
967 if let Some(extra_child) = children.next() {
968 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
969 }
970 Ok(result)
971 }
972}
973#[derive(Debug, Clone, Copy, PartialEq, Eq)]
974pub enum BindingRhsView {
975 ValueBinding(ValueBindingHandle),
976 SectionBinding(SectionBindingHandle),
977 TextBinding(TextBindingHandle),
978}
979impl BindingRhsView {}
980#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
981pub struct BooleanHandle(pub(crate) super::tree::CstNodeId);
982impl NonTerminalHandle for BooleanHandle {
983 type View = BooleanView;
984 fn node_id(&self) -> CstNodeId {
985 self.0
986 }
987 fn new_with_visit<F: CstFacade, E>(
988 index: CstNodeId,
989 tree: &F,
990 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
991 ) -> Result<Self, CstConstructError<E>> {
992 tree.collect_nodes(
993 index,
994 [NodeKind::NonTerminal(NonTerminalKind::Boolean)],
995 |[index], visit| Ok((Self(index), visit)),
996 visit_ignored,
997 )
998 }
999 fn kind(&self) -> NonTerminalKind {
1000 NonTerminalKind::Boolean
1001 }
1002 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1003 &self,
1004 tree: &F,
1005 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1006 visit_ignored: &'v mut V,
1007 ) -> Result<O, CstConstructError<E>> {
1008 let mut children = tree.children(self.0);
1009 let Some(child) = children.next() else {
1010 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1011 };
1012 let Some(child_data) = tree.node_data(child) else {
1013 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1014 };
1015 let variant = match child_data.node_kind() {
1016 NodeKind::NonTerminal(NonTerminalKind::True) => BooleanView::True(TrueHandle(child)),
1017 NodeKind::NonTerminal(NonTerminalKind::False) => BooleanView::False(FalseHandle(child)),
1018 _ => {
1019 return Err(ViewConstructionError::UnexpectedNode {
1020 node: child,
1021 data: child_data,
1022 expected_kind: child_data.node_kind(),
1023 });
1024 }
1025 };
1026 let (result, _visit) = visit(variant, visit_ignored);
1027 if let Some(extra_child) = children.next() {
1028 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1029 }
1030 Ok(result)
1031 }
1032}
1033#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1034pub enum BooleanView {
1035 True(TrueHandle),
1036 False(FalseHandle),
1037}
1038impl BooleanView {}
1039#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1040pub struct CodeBlockHandle(pub(crate) super::tree::CstNodeId);
1041impl NonTerminalHandle for CodeBlockHandle {
1042 type View = CodeBlockView;
1043 fn node_id(&self) -> CstNodeId {
1044 self.0
1045 }
1046 fn new_with_visit<F: CstFacade, E>(
1047 index: CstNodeId,
1048 tree: &F,
1049 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1050 ) -> Result<Self, CstConstructError<E>> {
1051 tree.collect_nodes(
1052 index,
1053 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock)],
1054 |[index], visit| Ok((Self(index), visit)),
1055 visit_ignored,
1056 )
1057 }
1058 fn kind(&self) -> NonTerminalKind {
1059 NonTerminalKind::CodeBlock
1060 }
1061 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1062 &self,
1063 tree: &F,
1064 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1065 visit_ignored: &'v mut V,
1066 ) -> Result<O, CstConstructError<E>> {
1067 let mut children = tree.children(self.0);
1068 let Some(child) = children.next() else {
1069 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1070 };
1071 let Some(child_data) = tree.node_data(child) else {
1072 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1073 };
1074 let variant = match child_data.node_kind() {
1075 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3) => {
1076 CodeBlockView::CodeBlock3(CodeBlock3Handle(child))
1077 }
1078 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4) => {
1079 CodeBlockView::CodeBlock4(CodeBlock4Handle(child))
1080 }
1081 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5) => {
1082 CodeBlockView::CodeBlock5(CodeBlock5Handle(child))
1083 }
1084 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6) => {
1085 CodeBlockView::CodeBlock6(CodeBlock6Handle(child))
1086 }
1087 _ => {
1088 return Err(ViewConstructionError::UnexpectedNode {
1089 node: child,
1090 data: child_data,
1091 expected_kind: child_data.node_kind(),
1092 });
1093 }
1094 };
1095 let (result, _visit) = visit(variant, visit_ignored);
1096 if let Some(extra_child) = children.next() {
1097 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1098 }
1099 Ok(result)
1100 }
1101}
1102#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1103pub enum CodeBlockView {
1104 CodeBlock3(CodeBlock3Handle),
1105 CodeBlock4(CodeBlock4Handle),
1106 CodeBlock5(CodeBlock5Handle),
1107 CodeBlock6(CodeBlock6Handle),
1108}
1109impl CodeBlockView {}
1110#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1111pub struct CodeBlock3Handle(pub(crate) super::tree::CstNodeId);
1112impl NonTerminalHandle for CodeBlock3Handle {
1113 type View = CodeBlock3View;
1114 fn node_id(&self) -> CstNodeId {
1115 self.0
1116 }
1117 fn new_with_visit<F: CstFacade, E>(
1118 index: CstNodeId,
1119 tree: &F,
1120 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1121 ) -> Result<Self, CstConstructError<E>> {
1122 tree.collect_nodes(
1123 index,
1124 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock3)],
1125 |[index], visit| Ok((Self(index), visit)),
1126 visit_ignored,
1127 )
1128 }
1129 fn kind(&self) -> NonTerminalKind {
1130 NonTerminalKind::CodeBlock3
1131 }
1132 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1133 &self,
1134 tree: &F,
1135 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1136 visit_ignored: &'v mut V,
1137 ) -> Result<O, CstConstructError<E>> {
1138 tree.collect_nodes(
1139 self.0,
1140 [
1141 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart3),
1142 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3List),
1143 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd3),
1144 ],
1145 |[code_block_start_3, code_block_3_list, code_block_end_3], visit_ignored| {
1146 Ok(visit(
1147 CodeBlock3View {
1148 code_block_start_3: CodeBlockStart3Handle(code_block_start_3),
1149 code_block_3_list: CodeBlock3ListHandle(code_block_3_list),
1150 code_block_end_3: CodeBlockEnd3Handle(code_block_end_3),
1151 },
1152 visit_ignored,
1153 ))
1154 },
1155 visit_ignored,
1156 )
1157 }
1158}
1159#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1160pub struct CodeBlock3View {
1161 pub code_block_start_3: CodeBlockStart3Handle,
1162 pub code_block_3_list: CodeBlock3ListHandle,
1163 pub code_block_end_3: CodeBlockEnd3Handle,
1164}
1165impl CodeBlock3View {}
1166#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1167pub struct CodeBlock3ListHandle(pub(crate) super::tree::CstNodeId);
1168impl NonTerminalHandle for CodeBlock3ListHandle {
1169 type View = Option<CodeBlock3ListView>;
1170 fn node_id(&self) -> CstNodeId {
1171 self.0
1172 }
1173 fn new_with_visit<F: CstFacade, E>(
1174 index: CstNodeId,
1175 tree: &F,
1176 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1177 ) -> Result<Self, CstConstructError<E>> {
1178 tree.collect_nodes(
1179 index,
1180 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock3List)],
1181 |[index], visit| Ok((Self(index), visit)),
1182 visit_ignored,
1183 )
1184 }
1185 fn kind(&self) -> NonTerminalKind {
1186 NonTerminalKind::CodeBlock3List
1187 }
1188 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1189 &self,
1190 tree: &F,
1191 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1192 visit_ignored: &'v mut V,
1193 ) -> Result<O, CstConstructError<E>> {
1194 if tree.has_no_children(self.0) {
1195 return Ok(visit(None, visit_ignored).0);
1196 }
1197 tree.collect_nodes(
1198 self.0,
1199 [
1200 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3ListGroup),
1201 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3List),
1202 ],
1203 |[code_block_3_list_group, code_block_3_list], visit_ignored| {
1204 Ok(visit(
1205 Some(CodeBlock3ListView {
1206 code_block_3_list_group: CodeBlock3ListGroupHandle(code_block_3_list_group),
1207 code_block_3_list: CodeBlock3ListHandle(code_block_3_list),
1208 }),
1209 visit_ignored,
1210 ))
1211 },
1212 visit_ignored,
1213 )
1214 }
1215}
1216#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1217pub struct CodeBlock3ListView {
1218 pub code_block_3_list_group: CodeBlock3ListGroupHandle,
1219 pub code_block_3_list: CodeBlock3ListHandle,
1220}
1221impl<F: CstFacade> RecursiveView<F> for CodeBlock3ListView {
1222 type Item = CodeBlock3ListGroupHandle;
1223 fn get_all_with_visit<E>(
1224 &self,
1225 tree: &F,
1226 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1227 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1228 let mut items = Vec::new();
1229 let mut current_view = Some(*self);
1230 while let Some(item) = current_view {
1231 let Self {
1232 code_block_3_list_group,
1233 ..
1234 } = item;
1235 items.push(code_block_3_list_group);
1236 item.code_block_3_list.get_view_with_visit(
1237 tree,
1238 |view, visit_ignored| {
1239 current_view = view;
1240 ((), visit_ignored)
1241 },
1242 visit_ignored,
1243 )?;
1244 }
1245 Ok(items)
1246 }
1247}
1248#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1249pub struct CodeBlock3ListGroupHandle(pub(crate) super::tree::CstNodeId);
1250impl NonTerminalHandle for CodeBlock3ListGroupHandle {
1251 type View = CodeBlock3ListGroupView;
1252 fn node_id(&self) -> CstNodeId {
1253 self.0
1254 }
1255 fn new_with_visit<F: CstFacade, E>(
1256 index: CstNodeId,
1257 tree: &F,
1258 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1259 ) -> Result<Self, CstConstructError<E>> {
1260 tree.collect_nodes(
1261 index,
1262 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock3ListGroup)],
1263 |[index], visit| Ok((Self(index), visit)),
1264 visit_ignored,
1265 )
1266 }
1267 fn kind(&self) -> NonTerminalKind {
1268 NonTerminalKind::CodeBlock3ListGroup
1269 }
1270 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1271 &self,
1272 tree: &F,
1273 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1274 visit_ignored: &'v mut V,
1275 ) -> Result<O, CstConstructError<E>> {
1276 let mut children = tree.children(self.0);
1277 let Some(child) = children.next() else {
1278 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1279 };
1280 let Some(child_data) = tree.node_data(child) else {
1281 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1282 };
1283 let variant = match child_data.node_kind() {
1284 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1285 CodeBlock3ListGroupView::NoBacktick(NoBacktickHandle(child))
1286 }
1287 NodeKind::NonTerminal(NonTerminalKind::Backtick2) => {
1288 CodeBlock3ListGroupView::Backtick2(Backtick2Handle(child))
1289 }
1290 _ => {
1291 return Err(ViewConstructionError::UnexpectedNode {
1292 node: child,
1293 data: child_data,
1294 expected_kind: child_data.node_kind(),
1295 });
1296 }
1297 };
1298 let (result, _visit) = visit(variant, visit_ignored);
1299 if let Some(extra_child) = children.next() {
1300 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1301 }
1302 Ok(result)
1303 }
1304}
1305#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1306pub enum CodeBlock3ListGroupView {
1307 NoBacktick(NoBacktickHandle),
1308 Backtick2(Backtick2Handle),
1309}
1310impl CodeBlock3ListGroupView {}
1311#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1312pub struct CodeBlock4Handle(pub(crate) super::tree::CstNodeId);
1313impl NonTerminalHandle for CodeBlock4Handle {
1314 type View = CodeBlock4View;
1315 fn node_id(&self) -> CstNodeId {
1316 self.0
1317 }
1318 fn new_with_visit<F: CstFacade, E>(
1319 index: CstNodeId,
1320 tree: &F,
1321 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1322 ) -> Result<Self, CstConstructError<E>> {
1323 tree.collect_nodes(
1324 index,
1325 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock4)],
1326 |[index], visit| Ok((Self(index), visit)),
1327 visit_ignored,
1328 )
1329 }
1330 fn kind(&self) -> NonTerminalKind {
1331 NonTerminalKind::CodeBlock4
1332 }
1333 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1334 &self,
1335 tree: &F,
1336 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1337 visit_ignored: &'v mut V,
1338 ) -> Result<O, CstConstructError<E>> {
1339 tree.collect_nodes(
1340 self.0,
1341 [
1342 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart4),
1343 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4List),
1344 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd4),
1345 ],
1346 |[code_block_start_4, code_block_4_list, code_block_end_4], visit_ignored| {
1347 Ok(visit(
1348 CodeBlock4View {
1349 code_block_start_4: CodeBlockStart4Handle(code_block_start_4),
1350 code_block_4_list: CodeBlock4ListHandle(code_block_4_list),
1351 code_block_end_4: CodeBlockEnd4Handle(code_block_end_4),
1352 },
1353 visit_ignored,
1354 ))
1355 },
1356 visit_ignored,
1357 )
1358 }
1359}
1360#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1361pub struct CodeBlock4View {
1362 pub code_block_start_4: CodeBlockStart4Handle,
1363 pub code_block_4_list: CodeBlock4ListHandle,
1364 pub code_block_end_4: CodeBlockEnd4Handle,
1365}
1366impl CodeBlock4View {}
1367#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1368pub struct CodeBlock4ListHandle(pub(crate) super::tree::CstNodeId);
1369impl NonTerminalHandle for CodeBlock4ListHandle {
1370 type View = Option<CodeBlock4ListView>;
1371 fn node_id(&self) -> CstNodeId {
1372 self.0
1373 }
1374 fn new_with_visit<F: CstFacade, E>(
1375 index: CstNodeId,
1376 tree: &F,
1377 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1378 ) -> Result<Self, CstConstructError<E>> {
1379 tree.collect_nodes(
1380 index,
1381 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock4List)],
1382 |[index], visit| Ok((Self(index), visit)),
1383 visit_ignored,
1384 )
1385 }
1386 fn kind(&self) -> NonTerminalKind {
1387 NonTerminalKind::CodeBlock4List
1388 }
1389 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1390 &self,
1391 tree: &F,
1392 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1393 visit_ignored: &'v mut V,
1394 ) -> Result<O, CstConstructError<E>> {
1395 if tree.has_no_children(self.0) {
1396 return Ok(visit(None, visit_ignored).0);
1397 }
1398 tree.collect_nodes(
1399 self.0,
1400 [
1401 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4ListGroup),
1402 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4List),
1403 ],
1404 |[code_block_4_list_group, code_block_4_list], visit_ignored| {
1405 Ok(visit(
1406 Some(CodeBlock4ListView {
1407 code_block_4_list_group: CodeBlock4ListGroupHandle(code_block_4_list_group),
1408 code_block_4_list: CodeBlock4ListHandle(code_block_4_list),
1409 }),
1410 visit_ignored,
1411 ))
1412 },
1413 visit_ignored,
1414 )
1415 }
1416}
1417#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1418pub struct CodeBlock4ListView {
1419 pub code_block_4_list_group: CodeBlock4ListGroupHandle,
1420 pub code_block_4_list: CodeBlock4ListHandle,
1421}
1422impl<F: CstFacade> RecursiveView<F> for CodeBlock4ListView {
1423 type Item = CodeBlock4ListGroupHandle;
1424 fn get_all_with_visit<E>(
1425 &self,
1426 tree: &F,
1427 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1428 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1429 let mut items = Vec::new();
1430 let mut current_view = Some(*self);
1431 while let Some(item) = current_view {
1432 let Self {
1433 code_block_4_list_group,
1434 ..
1435 } = item;
1436 items.push(code_block_4_list_group);
1437 item.code_block_4_list.get_view_with_visit(
1438 tree,
1439 |view, visit_ignored| {
1440 current_view = view;
1441 ((), visit_ignored)
1442 },
1443 visit_ignored,
1444 )?;
1445 }
1446 Ok(items)
1447 }
1448}
1449#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1450pub struct CodeBlock4ListGroupHandle(pub(crate) super::tree::CstNodeId);
1451impl NonTerminalHandle for CodeBlock4ListGroupHandle {
1452 type View = CodeBlock4ListGroupView;
1453 fn node_id(&self) -> CstNodeId {
1454 self.0
1455 }
1456 fn new_with_visit<F: CstFacade, E>(
1457 index: CstNodeId,
1458 tree: &F,
1459 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1460 ) -> Result<Self, CstConstructError<E>> {
1461 tree.collect_nodes(
1462 index,
1463 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock4ListGroup)],
1464 |[index], visit| Ok((Self(index), visit)),
1465 visit_ignored,
1466 )
1467 }
1468 fn kind(&self) -> NonTerminalKind {
1469 NonTerminalKind::CodeBlock4ListGroup
1470 }
1471 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1472 &self,
1473 tree: &F,
1474 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1475 visit_ignored: &'v mut V,
1476 ) -> Result<O, CstConstructError<E>> {
1477 let mut children = tree.children(self.0);
1478 let Some(child) = children.next() else {
1479 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1480 };
1481 let Some(child_data) = tree.node_data(child) else {
1482 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1483 };
1484 let variant = match child_data.node_kind() {
1485 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1486 CodeBlock4ListGroupView::NoBacktick(NoBacktickHandle(child))
1487 }
1488 NodeKind::NonTerminal(NonTerminalKind::Backtick3) => {
1489 CodeBlock4ListGroupView::Backtick3(Backtick3Handle(child))
1490 }
1491 _ => {
1492 return Err(ViewConstructionError::UnexpectedNode {
1493 node: child,
1494 data: child_data,
1495 expected_kind: child_data.node_kind(),
1496 });
1497 }
1498 };
1499 let (result, _visit) = visit(variant, visit_ignored);
1500 if let Some(extra_child) = children.next() {
1501 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1502 }
1503 Ok(result)
1504 }
1505}
1506#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1507pub enum CodeBlock4ListGroupView {
1508 NoBacktick(NoBacktickHandle),
1509 Backtick3(Backtick3Handle),
1510}
1511impl CodeBlock4ListGroupView {}
1512#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1513pub struct CodeBlock5Handle(pub(crate) super::tree::CstNodeId);
1514impl NonTerminalHandle for CodeBlock5Handle {
1515 type View = CodeBlock5View;
1516 fn node_id(&self) -> CstNodeId {
1517 self.0
1518 }
1519 fn new_with_visit<F: CstFacade, E>(
1520 index: CstNodeId,
1521 tree: &F,
1522 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1523 ) -> Result<Self, CstConstructError<E>> {
1524 tree.collect_nodes(
1525 index,
1526 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock5)],
1527 |[index], visit| Ok((Self(index), visit)),
1528 visit_ignored,
1529 )
1530 }
1531 fn kind(&self) -> NonTerminalKind {
1532 NonTerminalKind::CodeBlock5
1533 }
1534 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1535 &self,
1536 tree: &F,
1537 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1538 visit_ignored: &'v mut V,
1539 ) -> Result<O, CstConstructError<E>> {
1540 tree.collect_nodes(
1541 self.0,
1542 [
1543 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart5),
1544 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5List),
1545 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd5),
1546 ],
1547 |[code_block_start_5, code_block_5_list, code_block_end_5], visit_ignored| {
1548 Ok(visit(
1549 CodeBlock5View {
1550 code_block_start_5: CodeBlockStart5Handle(code_block_start_5),
1551 code_block_5_list: CodeBlock5ListHandle(code_block_5_list),
1552 code_block_end_5: CodeBlockEnd5Handle(code_block_end_5),
1553 },
1554 visit_ignored,
1555 ))
1556 },
1557 visit_ignored,
1558 )
1559 }
1560}
1561#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1562pub struct CodeBlock5View {
1563 pub code_block_start_5: CodeBlockStart5Handle,
1564 pub code_block_5_list: CodeBlock5ListHandle,
1565 pub code_block_end_5: CodeBlockEnd5Handle,
1566}
1567impl CodeBlock5View {}
1568#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1569pub struct CodeBlock5ListHandle(pub(crate) super::tree::CstNodeId);
1570impl NonTerminalHandle for CodeBlock5ListHandle {
1571 type View = Option<CodeBlock5ListView>;
1572 fn node_id(&self) -> CstNodeId {
1573 self.0
1574 }
1575 fn new_with_visit<F: CstFacade, E>(
1576 index: CstNodeId,
1577 tree: &F,
1578 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1579 ) -> Result<Self, CstConstructError<E>> {
1580 tree.collect_nodes(
1581 index,
1582 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock5List)],
1583 |[index], visit| Ok((Self(index), visit)),
1584 visit_ignored,
1585 )
1586 }
1587 fn kind(&self) -> NonTerminalKind {
1588 NonTerminalKind::CodeBlock5List
1589 }
1590 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1591 &self,
1592 tree: &F,
1593 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1594 visit_ignored: &'v mut V,
1595 ) -> Result<O, CstConstructError<E>> {
1596 if tree.has_no_children(self.0) {
1597 return Ok(visit(None, visit_ignored).0);
1598 }
1599 tree.collect_nodes(
1600 self.0,
1601 [
1602 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5ListGroup),
1603 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5List),
1604 ],
1605 |[code_block_5_list_group, code_block_5_list], visit_ignored| {
1606 Ok(visit(
1607 Some(CodeBlock5ListView {
1608 code_block_5_list_group: CodeBlock5ListGroupHandle(code_block_5_list_group),
1609 code_block_5_list: CodeBlock5ListHandle(code_block_5_list),
1610 }),
1611 visit_ignored,
1612 ))
1613 },
1614 visit_ignored,
1615 )
1616 }
1617}
1618#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1619pub struct CodeBlock5ListView {
1620 pub code_block_5_list_group: CodeBlock5ListGroupHandle,
1621 pub code_block_5_list: CodeBlock5ListHandle,
1622}
1623impl<F: CstFacade> RecursiveView<F> for CodeBlock5ListView {
1624 type Item = CodeBlock5ListGroupHandle;
1625 fn get_all_with_visit<E>(
1626 &self,
1627 tree: &F,
1628 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1629 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1630 let mut items = Vec::new();
1631 let mut current_view = Some(*self);
1632 while let Some(item) = current_view {
1633 let Self {
1634 code_block_5_list_group,
1635 ..
1636 } = item;
1637 items.push(code_block_5_list_group);
1638 item.code_block_5_list.get_view_with_visit(
1639 tree,
1640 |view, visit_ignored| {
1641 current_view = view;
1642 ((), visit_ignored)
1643 },
1644 visit_ignored,
1645 )?;
1646 }
1647 Ok(items)
1648 }
1649}
1650#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1651pub struct CodeBlock5ListGroupHandle(pub(crate) super::tree::CstNodeId);
1652impl NonTerminalHandle for CodeBlock5ListGroupHandle {
1653 type View = CodeBlock5ListGroupView;
1654 fn node_id(&self) -> CstNodeId {
1655 self.0
1656 }
1657 fn new_with_visit<F: CstFacade, E>(
1658 index: CstNodeId,
1659 tree: &F,
1660 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1661 ) -> Result<Self, CstConstructError<E>> {
1662 tree.collect_nodes(
1663 index,
1664 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock5ListGroup)],
1665 |[index], visit| Ok((Self(index), visit)),
1666 visit_ignored,
1667 )
1668 }
1669 fn kind(&self) -> NonTerminalKind {
1670 NonTerminalKind::CodeBlock5ListGroup
1671 }
1672 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1673 &self,
1674 tree: &F,
1675 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1676 visit_ignored: &'v mut V,
1677 ) -> Result<O, CstConstructError<E>> {
1678 let mut children = tree.children(self.0);
1679 let Some(child) = children.next() else {
1680 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1681 };
1682 let Some(child_data) = tree.node_data(child) else {
1683 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1684 };
1685 let variant = match child_data.node_kind() {
1686 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1687 CodeBlock5ListGroupView::NoBacktick(NoBacktickHandle(child))
1688 }
1689 NodeKind::NonTerminal(NonTerminalKind::Backtick4) => {
1690 CodeBlock5ListGroupView::Backtick4(Backtick4Handle(child))
1691 }
1692 _ => {
1693 return Err(ViewConstructionError::UnexpectedNode {
1694 node: child,
1695 data: child_data,
1696 expected_kind: child_data.node_kind(),
1697 });
1698 }
1699 };
1700 let (result, _visit) = visit(variant, visit_ignored);
1701 if let Some(extra_child) = children.next() {
1702 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1703 }
1704 Ok(result)
1705 }
1706}
1707#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1708pub enum CodeBlock5ListGroupView {
1709 NoBacktick(NoBacktickHandle),
1710 Backtick4(Backtick4Handle),
1711}
1712impl CodeBlock5ListGroupView {}
1713#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1714pub struct CodeBlock6Handle(pub(crate) super::tree::CstNodeId);
1715impl NonTerminalHandle for CodeBlock6Handle {
1716 type View = CodeBlock6View;
1717 fn node_id(&self) -> CstNodeId {
1718 self.0
1719 }
1720 fn new_with_visit<F: CstFacade, E>(
1721 index: CstNodeId,
1722 tree: &F,
1723 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1724 ) -> Result<Self, CstConstructError<E>> {
1725 tree.collect_nodes(
1726 index,
1727 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock6)],
1728 |[index], visit| Ok((Self(index), visit)),
1729 visit_ignored,
1730 )
1731 }
1732 fn kind(&self) -> NonTerminalKind {
1733 NonTerminalKind::CodeBlock6
1734 }
1735 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1736 &self,
1737 tree: &F,
1738 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1739 visit_ignored: &'v mut V,
1740 ) -> Result<O, CstConstructError<E>> {
1741 tree.collect_nodes(
1742 self.0,
1743 [
1744 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart6),
1745 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6List),
1746 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd6),
1747 ],
1748 |[code_block_start_6, code_block_6_list, code_block_end_6], visit_ignored| {
1749 Ok(visit(
1750 CodeBlock6View {
1751 code_block_start_6: CodeBlockStart6Handle(code_block_start_6),
1752 code_block_6_list: CodeBlock6ListHandle(code_block_6_list),
1753 code_block_end_6: CodeBlockEnd6Handle(code_block_end_6),
1754 },
1755 visit_ignored,
1756 ))
1757 },
1758 visit_ignored,
1759 )
1760 }
1761}
1762#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1763pub struct CodeBlock6View {
1764 pub code_block_start_6: CodeBlockStart6Handle,
1765 pub code_block_6_list: CodeBlock6ListHandle,
1766 pub code_block_end_6: CodeBlockEnd6Handle,
1767}
1768impl CodeBlock6View {}
1769#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1770pub struct CodeBlock6ListHandle(pub(crate) super::tree::CstNodeId);
1771impl NonTerminalHandle for CodeBlock6ListHandle {
1772 type View = Option<CodeBlock6ListView>;
1773 fn node_id(&self) -> CstNodeId {
1774 self.0
1775 }
1776 fn new_with_visit<F: CstFacade, E>(
1777 index: CstNodeId,
1778 tree: &F,
1779 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1780 ) -> Result<Self, CstConstructError<E>> {
1781 tree.collect_nodes(
1782 index,
1783 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock6List)],
1784 |[index], visit| Ok((Self(index), visit)),
1785 visit_ignored,
1786 )
1787 }
1788 fn kind(&self) -> NonTerminalKind {
1789 NonTerminalKind::CodeBlock6List
1790 }
1791 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1792 &self,
1793 tree: &F,
1794 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1795 visit_ignored: &'v mut V,
1796 ) -> Result<O, CstConstructError<E>> {
1797 if tree.has_no_children(self.0) {
1798 return Ok(visit(None, visit_ignored).0);
1799 }
1800 tree.collect_nodes(
1801 self.0,
1802 [
1803 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6ListGroup),
1804 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6List),
1805 ],
1806 |[code_block_6_list_group, code_block_6_list], visit_ignored| {
1807 Ok(visit(
1808 Some(CodeBlock6ListView {
1809 code_block_6_list_group: CodeBlock6ListGroupHandle(code_block_6_list_group),
1810 code_block_6_list: CodeBlock6ListHandle(code_block_6_list),
1811 }),
1812 visit_ignored,
1813 ))
1814 },
1815 visit_ignored,
1816 )
1817 }
1818}
1819#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1820pub struct CodeBlock6ListView {
1821 pub code_block_6_list_group: CodeBlock6ListGroupHandle,
1822 pub code_block_6_list: CodeBlock6ListHandle,
1823}
1824impl<F: CstFacade> RecursiveView<F> for CodeBlock6ListView {
1825 type Item = CodeBlock6ListGroupHandle;
1826 fn get_all_with_visit<E>(
1827 &self,
1828 tree: &F,
1829 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1830 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1831 let mut items = Vec::new();
1832 let mut current_view = Some(*self);
1833 while let Some(item) = current_view {
1834 let Self {
1835 code_block_6_list_group,
1836 ..
1837 } = item;
1838 items.push(code_block_6_list_group);
1839 item.code_block_6_list.get_view_with_visit(
1840 tree,
1841 |view, visit_ignored| {
1842 current_view = view;
1843 ((), visit_ignored)
1844 },
1845 visit_ignored,
1846 )?;
1847 }
1848 Ok(items)
1849 }
1850}
1851#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1852pub struct CodeBlock6ListGroupHandle(pub(crate) super::tree::CstNodeId);
1853impl NonTerminalHandle for CodeBlock6ListGroupHandle {
1854 type View = CodeBlock6ListGroupView;
1855 fn node_id(&self) -> CstNodeId {
1856 self.0
1857 }
1858 fn new_with_visit<F: CstFacade, E>(
1859 index: CstNodeId,
1860 tree: &F,
1861 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1862 ) -> Result<Self, CstConstructError<E>> {
1863 tree.collect_nodes(
1864 index,
1865 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock6ListGroup)],
1866 |[index], visit| Ok((Self(index), visit)),
1867 visit_ignored,
1868 )
1869 }
1870 fn kind(&self) -> NonTerminalKind {
1871 NonTerminalKind::CodeBlock6ListGroup
1872 }
1873 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1874 &self,
1875 tree: &F,
1876 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1877 visit_ignored: &'v mut V,
1878 ) -> Result<O, CstConstructError<E>> {
1879 let mut children = tree.children(self.0);
1880 let Some(child) = children.next() else {
1881 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1882 };
1883 let Some(child_data) = tree.node_data(child) else {
1884 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1885 };
1886 let variant = match child_data.node_kind() {
1887 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1888 CodeBlock6ListGroupView::NoBacktick(NoBacktickHandle(child))
1889 }
1890 NodeKind::NonTerminal(NonTerminalKind::Backtick5) => {
1891 CodeBlock6ListGroupView::Backtick5(Backtick5Handle(child))
1892 }
1893 _ => {
1894 return Err(ViewConstructionError::UnexpectedNode {
1895 node: child,
1896 data: child_data,
1897 expected_kind: child_data.node_kind(),
1898 });
1899 }
1900 };
1901 let (result, _visit) = visit(variant, visit_ignored);
1902 if let Some(extra_child) = children.next() {
1903 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1904 }
1905 Ok(result)
1906 }
1907}
1908#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1909pub enum CodeBlock6ListGroupView {
1910 NoBacktick(NoBacktickHandle),
1911 Backtick5(Backtick5Handle),
1912}
1913impl CodeBlock6ListGroupView {}
1914#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1915pub struct CodeBlockEnd3Handle(pub(crate) super::tree::CstNodeId);
1916impl NonTerminalHandle for CodeBlockEnd3Handle {
1917 type View = CodeBlockEnd3View;
1918 fn node_id(&self) -> CstNodeId {
1919 self.0
1920 }
1921 fn new_with_visit<F: CstFacade, E>(
1922 index: CstNodeId,
1923 tree: &F,
1924 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1925 ) -> Result<Self, CstConstructError<E>> {
1926 tree.collect_nodes(
1927 index,
1928 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd3)],
1929 |[index], visit| Ok((Self(index), visit)),
1930 visit_ignored,
1931 )
1932 }
1933 fn kind(&self) -> NonTerminalKind {
1934 NonTerminalKind::CodeBlockEnd3
1935 }
1936 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1937 &self,
1938 tree: &F,
1939 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1940 visit_ignored: &'v mut V,
1941 ) -> Result<O, CstConstructError<E>> {
1942 tree.collect_nodes(
1943 self.0,
1944 [NodeKind::Terminal(TerminalKind::CodeBlockEnd3)],
1945 |[code_block_end_3], visit_ignored| {
1946 Ok(visit(
1947 CodeBlockEnd3View {
1948 code_block_end_3: CodeBlockEnd3(code_block_end_3),
1949 },
1950 visit_ignored,
1951 ))
1952 },
1953 visit_ignored,
1954 )
1955 }
1956}
1957#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1958pub struct CodeBlockEnd3View {
1959 pub code_block_end_3: CodeBlockEnd3,
1960}
1961impl CodeBlockEnd3View {}
1962#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1963pub struct CodeBlockEnd4Handle(pub(crate) super::tree::CstNodeId);
1964impl NonTerminalHandle for CodeBlockEnd4Handle {
1965 type View = CodeBlockEnd4View;
1966 fn node_id(&self) -> CstNodeId {
1967 self.0
1968 }
1969 fn new_with_visit<F: CstFacade, E>(
1970 index: CstNodeId,
1971 tree: &F,
1972 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1973 ) -> Result<Self, CstConstructError<E>> {
1974 tree.collect_nodes(
1975 index,
1976 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd4)],
1977 |[index], visit| Ok((Self(index), visit)),
1978 visit_ignored,
1979 )
1980 }
1981 fn kind(&self) -> NonTerminalKind {
1982 NonTerminalKind::CodeBlockEnd4
1983 }
1984 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1985 &self,
1986 tree: &F,
1987 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1988 visit_ignored: &'v mut V,
1989 ) -> Result<O, CstConstructError<E>> {
1990 tree.collect_nodes(
1991 self.0,
1992 [NodeKind::Terminal(TerminalKind::CodeBlockEnd4)],
1993 |[code_block_end_4], visit_ignored| {
1994 Ok(visit(
1995 CodeBlockEnd4View {
1996 code_block_end_4: CodeBlockEnd4(code_block_end_4),
1997 },
1998 visit_ignored,
1999 ))
2000 },
2001 visit_ignored,
2002 )
2003 }
2004}
2005#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2006pub struct CodeBlockEnd4View {
2007 pub code_block_end_4: CodeBlockEnd4,
2008}
2009impl CodeBlockEnd4View {}
2010#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2011pub struct CodeBlockEnd5Handle(pub(crate) super::tree::CstNodeId);
2012impl NonTerminalHandle for CodeBlockEnd5Handle {
2013 type View = CodeBlockEnd5View;
2014 fn node_id(&self) -> CstNodeId {
2015 self.0
2016 }
2017 fn new_with_visit<F: CstFacade, E>(
2018 index: CstNodeId,
2019 tree: &F,
2020 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2021 ) -> Result<Self, CstConstructError<E>> {
2022 tree.collect_nodes(
2023 index,
2024 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd5)],
2025 |[index], visit| Ok((Self(index), visit)),
2026 visit_ignored,
2027 )
2028 }
2029 fn kind(&self) -> NonTerminalKind {
2030 NonTerminalKind::CodeBlockEnd5
2031 }
2032 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2033 &self,
2034 tree: &F,
2035 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2036 visit_ignored: &'v mut V,
2037 ) -> Result<O, CstConstructError<E>> {
2038 tree.collect_nodes(
2039 self.0,
2040 [NodeKind::Terminal(TerminalKind::CodeBlockEnd5)],
2041 |[code_block_end_5], visit_ignored| {
2042 Ok(visit(
2043 CodeBlockEnd5View {
2044 code_block_end_5: CodeBlockEnd5(code_block_end_5),
2045 },
2046 visit_ignored,
2047 ))
2048 },
2049 visit_ignored,
2050 )
2051 }
2052}
2053#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2054pub struct CodeBlockEnd5View {
2055 pub code_block_end_5: CodeBlockEnd5,
2056}
2057impl CodeBlockEnd5View {}
2058#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2059pub struct CodeBlockEnd6Handle(pub(crate) super::tree::CstNodeId);
2060impl NonTerminalHandle for CodeBlockEnd6Handle {
2061 type View = CodeBlockEnd6View;
2062 fn node_id(&self) -> CstNodeId {
2063 self.0
2064 }
2065 fn new_with_visit<F: CstFacade, E>(
2066 index: CstNodeId,
2067 tree: &F,
2068 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2069 ) -> Result<Self, CstConstructError<E>> {
2070 tree.collect_nodes(
2071 index,
2072 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd6)],
2073 |[index], visit| Ok((Self(index), visit)),
2074 visit_ignored,
2075 )
2076 }
2077 fn kind(&self) -> NonTerminalKind {
2078 NonTerminalKind::CodeBlockEnd6
2079 }
2080 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2081 &self,
2082 tree: &F,
2083 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2084 visit_ignored: &'v mut V,
2085 ) -> Result<O, CstConstructError<E>> {
2086 tree.collect_nodes(
2087 self.0,
2088 [NodeKind::Terminal(TerminalKind::CodeBlockEnd6)],
2089 |[code_block_end_6], visit_ignored| {
2090 Ok(visit(
2091 CodeBlockEnd6View {
2092 code_block_end_6: CodeBlockEnd6(code_block_end_6),
2093 },
2094 visit_ignored,
2095 ))
2096 },
2097 visit_ignored,
2098 )
2099 }
2100}
2101#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2102pub struct CodeBlockEnd6View {
2103 pub code_block_end_6: CodeBlockEnd6,
2104}
2105impl CodeBlockEnd6View {}
2106#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2107pub struct CodeBlockStart3Handle(pub(crate) super::tree::CstNodeId);
2108impl NonTerminalHandle for CodeBlockStart3Handle {
2109 type View = CodeBlockStart3View;
2110 fn node_id(&self) -> CstNodeId {
2111 self.0
2112 }
2113 fn new_with_visit<F: CstFacade, E>(
2114 index: CstNodeId,
2115 tree: &F,
2116 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2117 ) -> Result<Self, CstConstructError<E>> {
2118 tree.collect_nodes(
2119 index,
2120 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart3)],
2121 |[index], visit| Ok((Self(index), visit)),
2122 visit_ignored,
2123 )
2124 }
2125 fn kind(&self) -> NonTerminalKind {
2126 NonTerminalKind::CodeBlockStart3
2127 }
2128 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2129 &self,
2130 tree: &F,
2131 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2132 visit_ignored: &'v mut V,
2133 ) -> Result<O, CstConstructError<E>> {
2134 tree.collect_nodes(
2135 self.0,
2136 [NodeKind::Terminal(TerminalKind::CodeBlockStart3)],
2137 |[code_block_start_3], visit_ignored| {
2138 Ok(visit(
2139 CodeBlockStart3View {
2140 code_block_start_3: CodeBlockStart3(code_block_start_3),
2141 },
2142 visit_ignored,
2143 ))
2144 },
2145 visit_ignored,
2146 )
2147 }
2148}
2149#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2150pub struct CodeBlockStart3View {
2151 pub code_block_start_3: CodeBlockStart3,
2152}
2153impl CodeBlockStart3View {}
2154#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2155pub struct CodeBlockStart4Handle(pub(crate) super::tree::CstNodeId);
2156impl NonTerminalHandle for CodeBlockStart4Handle {
2157 type View = CodeBlockStart4View;
2158 fn node_id(&self) -> CstNodeId {
2159 self.0
2160 }
2161 fn new_with_visit<F: CstFacade, E>(
2162 index: CstNodeId,
2163 tree: &F,
2164 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2165 ) -> Result<Self, CstConstructError<E>> {
2166 tree.collect_nodes(
2167 index,
2168 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart4)],
2169 |[index], visit| Ok((Self(index), visit)),
2170 visit_ignored,
2171 )
2172 }
2173 fn kind(&self) -> NonTerminalKind {
2174 NonTerminalKind::CodeBlockStart4
2175 }
2176 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2177 &self,
2178 tree: &F,
2179 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2180 visit_ignored: &'v mut V,
2181 ) -> Result<O, CstConstructError<E>> {
2182 tree.collect_nodes(
2183 self.0,
2184 [NodeKind::Terminal(TerminalKind::CodeBlockStart4)],
2185 |[code_block_start_4], visit_ignored| {
2186 Ok(visit(
2187 CodeBlockStart4View {
2188 code_block_start_4: CodeBlockStart4(code_block_start_4),
2189 },
2190 visit_ignored,
2191 ))
2192 },
2193 visit_ignored,
2194 )
2195 }
2196}
2197#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2198pub struct CodeBlockStart4View {
2199 pub code_block_start_4: CodeBlockStart4,
2200}
2201impl CodeBlockStart4View {}
2202#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2203pub struct CodeBlockStart5Handle(pub(crate) super::tree::CstNodeId);
2204impl NonTerminalHandle for CodeBlockStart5Handle {
2205 type View = CodeBlockStart5View;
2206 fn node_id(&self) -> CstNodeId {
2207 self.0
2208 }
2209 fn new_with_visit<F: CstFacade, E>(
2210 index: CstNodeId,
2211 tree: &F,
2212 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2213 ) -> Result<Self, CstConstructError<E>> {
2214 tree.collect_nodes(
2215 index,
2216 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart5)],
2217 |[index], visit| Ok((Self(index), visit)),
2218 visit_ignored,
2219 )
2220 }
2221 fn kind(&self) -> NonTerminalKind {
2222 NonTerminalKind::CodeBlockStart5
2223 }
2224 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2225 &self,
2226 tree: &F,
2227 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2228 visit_ignored: &'v mut V,
2229 ) -> Result<O, CstConstructError<E>> {
2230 tree.collect_nodes(
2231 self.0,
2232 [NodeKind::Terminal(TerminalKind::CodeBlockStart5)],
2233 |[code_block_start_5], visit_ignored| {
2234 Ok(visit(
2235 CodeBlockStart5View {
2236 code_block_start_5: CodeBlockStart5(code_block_start_5),
2237 },
2238 visit_ignored,
2239 ))
2240 },
2241 visit_ignored,
2242 )
2243 }
2244}
2245#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2246pub struct CodeBlockStart5View {
2247 pub code_block_start_5: CodeBlockStart5,
2248}
2249impl CodeBlockStart5View {}
2250#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2251pub struct CodeBlockStart6Handle(pub(crate) super::tree::CstNodeId);
2252impl NonTerminalHandle for CodeBlockStart6Handle {
2253 type View = CodeBlockStart6View;
2254 fn node_id(&self) -> CstNodeId {
2255 self.0
2256 }
2257 fn new_with_visit<F: CstFacade, E>(
2258 index: CstNodeId,
2259 tree: &F,
2260 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2261 ) -> Result<Self, CstConstructError<E>> {
2262 tree.collect_nodes(
2263 index,
2264 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart6)],
2265 |[index], visit| Ok((Self(index), visit)),
2266 visit_ignored,
2267 )
2268 }
2269 fn kind(&self) -> NonTerminalKind {
2270 NonTerminalKind::CodeBlockStart6
2271 }
2272 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2273 &self,
2274 tree: &F,
2275 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2276 visit_ignored: &'v mut V,
2277 ) -> Result<O, CstConstructError<E>> {
2278 tree.collect_nodes(
2279 self.0,
2280 [NodeKind::Terminal(TerminalKind::CodeBlockStart6)],
2281 |[code_block_start_6], visit_ignored| {
2282 Ok(visit(
2283 CodeBlockStart6View {
2284 code_block_start_6: CodeBlockStart6(code_block_start_6),
2285 },
2286 visit_ignored,
2287 ))
2288 },
2289 visit_ignored,
2290 )
2291 }
2292}
2293#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2294pub struct CodeBlockStart6View {
2295 pub code_block_start_6: CodeBlockStart6,
2296}
2297impl CodeBlockStart6View {}
2298#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2299pub struct CommaHandle(pub(crate) super::tree::CstNodeId);
2300impl NonTerminalHandle for CommaHandle {
2301 type View = CommaView;
2302 fn node_id(&self) -> CstNodeId {
2303 self.0
2304 }
2305 fn new_with_visit<F: CstFacade, E>(
2306 index: CstNodeId,
2307 tree: &F,
2308 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2309 ) -> Result<Self, CstConstructError<E>> {
2310 tree.collect_nodes(
2311 index,
2312 [NodeKind::NonTerminal(NonTerminalKind::Comma)],
2313 |[index], visit| Ok((Self(index), visit)),
2314 visit_ignored,
2315 )
2316 }
2317 fn kind(&self) -> NonTerminalKind {
2318 NonTerminalKind::Comma
2319 }
2320 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2321 &self,
2322 tree: &F,
2323 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2324 visit_ignored: &'v mut V,
2325 ) -> Result<O, CstConstructError<E>> {
2326 tree.collect_nodes(
2327 self.0,
2328 [NodeKind::Terminal(TerminalKind::Comma)],
2329 |[comma], visit_ignored| {
2330 Ok(visit(
2331 CommaView {
2332 comma: Comma(comma),
2333 },
2334 visit_ignored,
2335 ))
2336 },
2337 visit_ignored,
2338 )
2339 }
2340}
2341#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2342pub struct CommaView {
2343 pub comma: Comma,
2344}
2345impl CommaView {}
2346#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2347pub struct ContinueHandle(pub(crate) super::tree::CstNodeId);
2348impl NonTerminalHandle for ContinueHandle {
2349 type View = ContinueView;
2350 fn node_id(&self) -> CstNodeId {
2351 self.0
2352 }
2353 fn new_with_visit<F: CstFacade, E>(
2354 index: CstNodeId,
2355 tree: &F,
2356 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2357 ) -> Result<Self, CstConstructError<E>> {
2358 tree.collect_nodes(
2359 index,
2360 [NodeKind::NonTerminal(NonTerminalKind::Continue)],
2361 |[index], visit| Ok((Self(index), visit)),
2362 visit_ignored,
2363 )
2364 }
2365 fn kind(&self) -> NonTerminalKind {
2366 NonTerminalKind::Continue
2367 }
2368 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2369 &self,
2370 tree: &F,
2371 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2372 visit_ignored: &'v mut V,
2373 ) -> Result<O, CstConstructError<E>> {
2374 tree.collect_nodes(
2375 self.0,
2376 [NodeKind::Terminal(TerminalKind::Esc)],
2377 |[esc], visit_ignored| Ok(visit(ContinueView { esc: Esc(esc) }, visit_ignored)),
2378 visit_ignored,
2379 )
2380 }
2381}
2382#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2383pub struct ContinueView {
2384 pub esc: Esc,
2385}
2386impl ContinueView {}
2387#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2388pub struct DotHandle(pub(crate) super::tree::CstNodeId);
2389impl NonTerminalHandle for DotHandle {
2390 type View = DotView;
2391 fn node_id(&self) -> CstNodeId {
2392 self.0
2393 }
2394 fn new_with_visit<F: CstFacade, E>(
2395 index: CstNodeId,
2396 tree: &F,
2397 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2398 ) -> Result<Self, CstConstructError<E>> {
2399 tree.collect_nodes(
2400 index,
2401 [NodeKind::NonTerminal(NonTerminalKind::Dot)],
2402 |[index], visit| Ok((Self(index), visit)),
2403 visit_ignored,
2404 )
2405 }
2406 fn kind(&self) -> NonTerminalKind {
2407 NonTerminalKind::Dot
2408 }
2409 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2410 &self,
2411 tree: &F,
2412 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2413 visit_ignored: &'v mut V,
2414 ) -> Result<O, CstConstructError<E>> {
2415 tree.collect_nodes(
2416 self.0,
2417 [NodeKind::Terminal(TerminalKind::Dot)],
2418 |[dot], visit_ignored| Ok(visit(DotView { dot: Dot(dot) }, visit_ignored)),
2419 visit_ignored,
2420 )
2421 }
2422}
2423#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2424pub struct DotView {
2425 pub dot: Dot,
2426}
2427impl DotView {}
2428#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2429pub struct EndHandle(pub(crate) super::tree::CstNodeId);
2430impl NonTerminalHandle for EndHandle {
2431 type View = EndView;
2432 fn node_id(&self) -> CstNodeId {
2433 self.0
2434 }
2435 fn new_with_visit<F: CstFacade, E>(
2436 index: CstNodeId,
2437 tree: &F,
2438 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2439 ) -> Result<Self, CstConstructError<E>> {
2440 tree.collect_nodes(
2441 index,
2442 [NodeKind::NonTerminal(NonTerminalKind::End)],
2443 |[index], visit| Ok((Self(index), visit)),
2444 visit_ignored,
2445 )
2446 }
2447 fn kind(&self) -> NonTerminalKind {
2448 NonTerminalKind::End
2449 }
2450 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2451 &self,
2452 tree: &F,
2453 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2454 visit_ignored: &'v mut V,
2455 ) -> Result<O, CstConstructError<E>> {
2456 tree.collect_nodes(
2457 self.0,
2458 [NodeKind::Terminal(TerminalKind::RBrace)],
2459 |[r_brace], visit_ignored| {
2460 Ok(visit(
2461 EndView {
2462 r_brace: RBrace(r_brace),
2463 },
2464 visit_ignored,
2465 ))
2466 },
2467 visit_ignored,
2468 )
2469 }
2470}
2471#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2472pub struct EndView {
2473 pub r_brace: RBrace,
2474}
2475impl EndView {}
2476#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2477pub struct EureHandle(pub(crate) super::tree::CstNodeId);
2478impl NonTerminalHandle for EureHandle {
2479 type View = EureView;
2480 fn node_id(&self) -> CstNodeId {
2481 self.0
2482 }
2483 fn new_with_visit<F: CstFacade, E>(
2484 index: CstNodeId,
2485 tree: &F,
2486 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2487 ) -> Result<Self, CstConstructError<E>> {
2488 tree.collect_nodes(
2489 index,
2490 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
2491 |[index], visit| Ok((Self(index), visit)),
2492 visit_ignored,
2493 )
2494 }
2495 fn kind(&self) -> NonTerminalKind {
2496 NonTerminalKind::Eure
2497 }
2498 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2499 &self,
2500 tree: &F,
2501 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2502 visit_ignored: &'v mut V,
2503 ) -> Result<O, CstConstructError<E>> {
2504 tree.collect_nodes(
2505 self.0,
2506 [
2507 NodeKind::NonTerminal(NonTerminalKind::EureOpt),
2508 NodeKind::NonTerminal(NonTerminalKind::EureList),
2509 NodeKind::NonTerminal(NonTerminalKind::EureList0),
2510 ],
2511 |[eure_opt, eure_bindings, eure_sections], visit_ignored| {
2512 Ok(visit(
2513 EureView {
2514 eure_opt: EureOptHandle(eure_opt),
2515 eure_bindings: EureBindingsHandle(eure_bindings),
2516 eure_sections: EureSectionsHandle(eure_sections),
2517 },
2518 visit_ignored,
2519 ))
2520 },
2521 visit_ignored,
2522 )
2523 }
2524}
2525#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2526pub struct EureView {
2527 pub eure_opt: EureOptHandle,
2528 pub eure_bindings: EureBindingsHandle,
2529 pub eure_sections: EureSectionsHandle,
2530}
2531impl EureView {}
2532#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2533pub struct EureBindingsHandle(pub(crate) super::tree::CstNodeId);
2534impl NonTerminalHandle for EureBindingsHandle {
2535 type View = Option<EureBindingsView>;
2536 fn node_id(&self) -> CstNodeId {
2537 self.0
2538 }
2539 fn new_with_visit<F: CstFacade, E>(
2540 index: CstNodeId,
2541 tree: &F,
2542 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2543 ) -> Result<Self, CstConstructError<E>> {
2544 tree.collect_nodes(
2545 index,
2546 [NodeKind::NonTerminal(NonTerminalKind::EureList)],
2547 |[index], visit| Ok((Self(index), visit)),
2548 visit_ignored,
2549 )
2550 }
2551 fn kind(&self) -> NonTerminalKind {
2552 NonTerminalKind::EureList
2553 }
2554 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2555 &self,
2556 tree: &F,
2557 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2558 visit_ignored: &'v mut V,
2559 ) -> Result<O, CstConstructError<E>> {
2560 if tree.has_no_children(self.0) {
2561 return Ok(visit(None, visit_ignored).0);
2562 }
2563 tree.collect_nodes(
2564 self.0,
2565 [
2566 NodeKind::NonTerminal(NonTerminalKind::Binding),
2567 NodeKind::NonTerminal(NonTerminalKind::EureList),
2568 ],
2569 |[binding, eure_bindings], visit_ignored| {
2570 Ok(visit(
2571 Some(EureBindingsView {
2572 binding: BindingHandle(binding),
2573 eure_bindings: EureBindingsHandle(eure_bindings),
2574 }),
2575 visit_ignored,
2576 ))
2577 },
2578 visit_ignored,
2579 )
2580 }
2581}
2582#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2583pub struct EureBindingsView {
2584 pub binding: BindingHandle,
2585 pub eure_bindings: EureBindingsHandle,
2586}
2587impl<F: CstFacade> RecursiveView<F> for EureBindingsView {
2588 type Item = BindingHandle;
2589 fn get_all_with_visit<E>(
2590 &self,
2591 tree: &F,
2592 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2593 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2594 let mut items = Vec::new();
2595 let mut current_view = Some(*self);
2596 while let Some(item) = current_view {
2597 let Self { binding, .. } = item;
2598 items.push(binding);
2599 item.eure_bindings.get_view_with_visit(
2600 tree,
2601 |view, visit_ignored| {
2602 current_view = view;
2603 ((), visit_ignored)
2604 },
2605 visit_ignored,
2606 )?;
2607 }
2608 Ok(items)
2609 }
2610}
2611#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2612pub struct EureSectionsHandle(pub(crate) super::tree::CstNodeId);
2613impl NonTerminalHandle for EureSectionsHandle {
2614 type View = Option<EureSectionsView>;
2615 fn node_id(&self) -> CstNodeId {
2616 self.0
2617 }
2618 fn new_with_visit<F: CstFacade, E>(
2619 index: CstNodeId,
2620 tree: &F,
2621 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2622 ) -> Result<Self, CstConstructError<E>> {
2623 tree.collect_nodes(
2624 index,
2625 [NodeKind::NonTerminal(NonTerminalKind::EureList0)],
2626 |[index], visit| Ok((Self(index), visit)),
2627 visit_ignored,
2628 )
2629 }
2630 fn kind(&self) -> NonTerminalKind {
2631 NonTerminalKind::EureList0
2632 }
2633 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2634 &self,
2635 tree: &F,
2636 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2637 visit_ignored: &'v mut V,
2638 ) -> Result<O, CstConstructError<E>> {
2639 if tree.has_no_children(self.0) {
2640 return Ok(visit(None, visit_ignored).0);
2641 }
2642 tree.collect_nodes(
2643 self.0,
2644 [
2645 NodeKind::NonTerminal(NonTerminalKind::Section),
2646 NodeKind::NonTerminal(NonTerminalKind::EureList0),
2647 ],
2648 |[section, eure_sections], visit_ignored| {
2649 Ok(visit(
2650 Some(EureSectionsView {
2651 section: SectionHandle(section),
2652 eure_sections: EureSectionsHandle(eure_sections),
2653 }),
2654 visit_ignored,
2655 ))
2656 },
2657 visit_ignored,
2658 )
2659 }
2660}
2661#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2662pub struct EureSectionsView {
2663 pub section: SectionHandle,
2664 pub eure_sections: EureSectionsHandle,
2665}
2666impl<F: CstFacade> RecursiveView<F> for EureSectionsView {
2667 type Item = SectionHandle;
2668 fn get_all_with_visit<E>(
2669 &self,
2670 tree: &F,
2671 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2672 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2673 let mut items = Vec::new();
2674 let mut current_view = Some(*self);
2675 while let Some(item) = current_view {
2676 let Self { section, .. } = item;
2677 items.push(section);
2678 item.eure_sections.get_view_with_visit(
2679 tree,
2680 |view, visit_ignored| {
2681 current_view = view;
2682 ((), visit_ignored)
2683 },
2684 visit_ignored,
2685 )?;
2686 }
2687 Ok(items)
2688 }
2689}
2690#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2691pub struct EureOptHandle(pub(crate) super::tree::CstNodeId);
2692impl NonTerminalHandle for EureOptHandle {
2693 type View = Option<ValueBindingHandle>;
2694 fn node_id(&self) -> CstNodeId {
2695 self.0
2696 }
2697 fn new_with_visit<F: CstFacade, E>(
2698 index: CstNodeId,
2699 tree: &F,
2700 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2701 ) -> Result<Self, CstConstructError<E>> {
2702 tree.collect_nodes(
2703 index,
2704 [NodeKind::NonTerminal(NonTerminalKind::EureOpt)],
2705 |[index], visit| Ok((Self(index), visit)),
2706 visit_ignored,
2707 )
2708 }
2709 fn kind(&self) -> NonTerminalKind {
2710 NonTerminalKind::EureOpt
2711 }
2712 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2713 &self,
2714 tree: &F,
2715 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2716 visit_ignored: &'v mut V,
2717 ) -> Result<O, CstConstructError<E>> {
2718 if tree.has_no_children(self.0) {
2719 return Ok(visit(None, visit_ignored).0);
2720 }
2721 Ok(visit(
2722 Some(ValueBindingHandle::new_with_visit(
2723 self.0,
2724 tree,
2725 visit_ignored,
2726 )?),
2727 visit_ignored,
2728 )
2729 .0)
2730 }
2731}
2732#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2733pub struct ExtHandle(pub(crate) super::tree::CstNodeId);
2734impl NonTerminalHandle for ExtHandle {
2735 type View = ExtView;
2736 fn node_id(&self) -> CstNodeId {
2737 self.0
2738 }
2739 fn new_with_visit<F: CstFacade, E>(
2740 index: CstNodeId,
2741 tree: &F,
2742 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2743 ) -> Result<Self, CstConstructError<E>> {
2744 tree.collect_nodes(
2745 index,
2746 [NodeKind::NonTerminal(NonTerminalKind::Ext)],
2747 |[index], visit| Ok((Self(index), visit)),
2748 visit_ignored,
2749 )
2750 }
2751 fn kind(&self) -> NonTerminalKind {
2752 NonTerminalKind::Ext
2753 }
2754 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2755 &self,
2756 tree: &F,
2757 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2758 visit_ignored: &'v mut V,
2759 ) -> Result<O, CstConstructError<E>> {
2760 tree.collect_nodes(
2761 self.0,
2762 [NodeKind::Terminal(TerminalKind::Dollar)],
2763 |[dollar], visit_ignored| {
2764 Ok(visit(
2765 ExtView {
2766 dollar: Dollar(dollar),
2767 },
2768 visit_ignored,
2769 ))
2770 },
2771 visit_ignored,
2772 )
2773 }
2774}
2775#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2776pub struct ExtView {
2777 pub dollar: Dollar,
2778}
2779impl ExtView {}
2780#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2781pub struct ExtensionNameSpaceHandle(pub(crate) super::tree::CstNodeId);
2782impl NonTerminalHandle for ExtensionNameSpaceHandle {
2783 type View = ExtensionNameSpaceView;
2784 fn node_id(&self) -> CstNodeId {
2785 self.0
2786 }
2787 fn new_with_visit<F: CstFacade, E>(
2788 index: CstNodeId,
2789 tree: &F,
2790 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2791 ) -> Result<Self, CstConstructError<E>> {
2792 tree.collect_nodes(
2793 index,
2794 [NodeKind::NonTerminal(NonTerminalKind::ExtensionNameSpace)],
2795 |[index], visit| Ok((Self(index), visit)),
2796 visit_ignored,
2797 )
2798 }
2799 fn kind(&self) -> NonTerminalKind {
2800 NonTerminalKind::ExtensionNameSpace
2801 }
2802 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2803 &self,
2804 tree: &F,
2805 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2806 visit_ignored: &'v mut V,
2807 ) -> Result<O, CstConstructError<E>> {
2808 tree.collect_nodes(
2809 self.0,
2810 [
2811 NodeKind::NonTerminal(NonTerminalKind::Ext),
2812 NodeKind::NonTerminal(NonTerminalKind::KeyIdent),
2813 ],
2814 |[ext, key_ident], visit_ignored| {
2815 Ok(visit(
2816 ExtensionNameSpaceView {
2817 ext: ExtHandle(ext),
2818 key_ident: KeyIdentHandle(key_ident),
2819 },
2820 visit_ignored,
2821 ))
2822 },
2823 visit_ignored,
2824 )
2825 }
2826}
2827#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2828pub struct ExtensionNameSpaceView {
2829 pub ext: ExtHandle,
2830 pub key_ident: KeyIdentHandle,
2831}
2832impl ExtensionNameSpaceView {}
2833#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2834pub struct FalseHandle(pub(crate) super::tree::CstNodeId);
2835impl NonTerminalHandle for FalseHandle {
2836 type View = FalseView;
2837 fn node_id(&self) -> CstNodeId {
2838 self.0
2839 }
2840 fn new_with_visit<F: CstFacade, E>(
2841 index: CstNodeId,
2842 tree: &F,
2843 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2844 ) -> Result<Self, CstConstructError<E>> {
2845 tree.collect_nodes(
2846 index,
2847 [NodeKind::NonTerminal(NonTerminalKind::False)],
2848 |[index], visit| Ok((Self(index), visit)),
2849 visit_ignored,
2850 )
2851 }
2852 fn kind(&self) -> NonTerminalKind {
2853 NonTerminalKind::False
2854 }
2855 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2856 &self,
2857 tree: &F,
2858 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2859 visit_ignored: &'v mut V,
2860 ) -> Result<O, CstConstructError<E>> {
2861 tree.collect_nodes(
2862 self.0,
2863 [NodeKind::Terminal(TerminalKind::False)],
2864 |[r#false], visit_ignored| {
2865 Ok(visit(
2866 FalseView {
2867 r#false: False(r#false),
2868 },
2869 visit_ignored,
2870 ))
2871 },
2872 visit_ignored,
2873 )
2874 }
2875}
2876#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2877pub struct FalseView {
2878 pub r#false: False,
2879}
2880impl FalseView {}
2881#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2882pub struct FloatHandle(pub(crate) super::tree::CstNodeId);
2883impl NonTerminalHandle for FloatHandle {
2884 type View = FloatView;
2885 fn node_id(&self) -> CstNodeId {
2886 self.0
2887 }
2888 fn new_with_visit<F: CstFacade, E>(
2889 index: CstNodeId,
2890 tree: &F,
2891 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2892 ) -> Result<Self, CstConstructError<E>> {
2893 tree.collect_nodes(
2894 index,
2895 [NodeKind::NonTerminal(NonTerminalKind::Float)],
2896 |[index], visit| Ok((Self(index), visit)),
2897 visit_ignored,
2898 )
2899 }
2900 fn kind(&self) -> NonTerminalKind {
2901 NonTerminalKind::Float
2902 }
2903 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2904 &self,
2905 tree: &F,
2906 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2907 visit_ignored: &'v mut V,
2908 ) -> Result<O, CstConstructError<E>> {
2909 tree.collect_nodes(
2910 self.0,
2911 [NodeKind::Terminal(TerminalKind::Float)],
2912 |[float], visit_ignored| {
2913 Ok(visit(
2914 FloatView {
2915 float: Float(float),
2916 },
2917 visit_ignored,
2918 ))
2919 },
2920 visit_ignored,
2921 )
2922 }
2923}
2924#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2925pub struct FloatView {
2926 pub float: Float,
2927}
2928impl FloatView {}
2929#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2930pub struct GrammarNewlineHandle(pub(crate) super::tree::CstNodeId);
2931impl NonTerminalHandle for GrammarNewlineHandle {
2932 type View = GrammarNewlineView;
2933 fn node_id(&self) -> CstNodeId {
2934 self.0
2935 }
2936 fn new_with_visit<F: CstFacade, E>(
2937 index: CstNodeId,
2938 tree: &F,
2939 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2940 ) -> Result<Self, CstConstructError<E>> {
2941 tree.collect_nodes(
2942 index,
2943 [NodeKind::NonTerminal(NonTerminalKind::GrammarNewline)],
2944 |[index], visit| Ok((Self(index), visit)),
2945 visit_ignored,
2946 )
2947 }
2948 fn kind(&self) -> NonTerminalKind {
2949 NonTerminalKind::GrammarNewline
2950 }
2951 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2952 &self,
2953 tree: &F,
2954 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2955 visit_ignored: &'v mut V,
2956 ) -> Result<O, CstConstructError<E>> {
2957 tree.collect_nodes(
2958 self.0,
2959 [NodeKind::Terminal(TerminalKind::GrammarNewline)],
2960 |[grammar_newline], visit_ignored| {
2961 Ok(visit(
2962 GrammarNewlineView {
2963 grammar_newline: GrammarNewline(grammar_newline),
2964 },
2965 visit_ignored,
2966 ))
2967 },
2968 visit_ignored,
2969 )
2970 }
2971}
2972#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2973pub struct GrammarNewlineView {
2974 pub grammar_newline: GrammarNewline,
2975}
2976impl GrammarNewlineView {}
2977#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2978pub struct HoleHandle(pub(crate) super::tree::CstNodeId);
2979impl NonTerminalHandle for HoleHandle {
2980 type View = HoleView;
2981 fn node_id(&self) -> CstNodeId {
2982 self.0
2983 }
2984 fn new_with_visit<F: CstFacade, E>(
2985 index: CstNodeId,
2986 tree: &F,
2987 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2988 ) -> Result<Self, CstConstructError<E>> {
2989 tree.collect_nodes(
2990 index,
2991 [NodeKind::NonTerminal(NonTerminalKind::Hole)],
2992 |[index], visit| Ok((Self(index), visit)),
2993 visit_ignored,
2994 )
2995 }
2996 fn kind(&self) -> NonTerminalKind {
2997 NonTerminalKind::Hole
2998 }
2999 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3000 &self,
3001 tree: &F,
3002 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3003 visit_ignored: &'v mut V,
3004 ) -> Result<O, CstConstructError<E>> {
3005 tree.collect_nodes(
3006 self.0,
3007 [NodeKind::Terminal(TerminalKind::Hole)],
3008 |[hole], visit_ignored| Ok(visit(HoleView { hole: Hole(hole) }, visit_ignored)),
3009 visit_ignored,
3010 )
3011 }
3012}
3013#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3014pub struct HoleView {
3015 pub hole: Hole,
3016}
3017impl HoleView {}
3018#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3019pub struct IdentHandle(pub(crate) super::tree::CstNodeId);
3020impl NonTerminalHandle for IdentHandle {
3021 type View = IdentView;
3022 fn node_id(&self) -> CstNodeId {
3023 self.0
3024 }
3025 fn new_with_visit<F: CstFacade, E>(
3026 index: CstNodeId,
3027 tree: &F,
3028 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3029 ) -> Result<Self, CstConstructError<E>> {
3030 tree.collect_nodes(
3031 index,
3032 [NodeKind::NonTerminal(NonTerminalKind::Ident)],
3033 |[index], visit| Ok((Self(index), visit)),
3034 visit_ignored,
3035 )
3036 }
3037 fn kind(&self) -> NonTerminalKind {
3038 NonTerminalKind::Ident
3039 }
3040 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3041 &self,
3042 tree: &F,
3043 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3044 visit_ignored: &'v mut V,
3045 ) -> Result<O, CstConstructError<E>> {
3046 tree.collect_nodes(
3047 self.0,
3048 [NodeKind::Terminal(TerminalKind::Ident)],
3049 |[ident], visit_ignored| {
3050 Ok(visit(
3051 IdentView {
3052 ident: Ident(ident),
3053 },
3054 visit_ignored,
3055 ))
3056 },
3057 visit_ignored,
3058 )
3059 }
3060}
3061#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3062pub struct IdentView {
3063 pub ident: Ident,
3064}
3065impl IdentView {}
3066#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3067pub struct InfHandle(pub(crate) super::tree::CstNodeId);
3068impl NonTerminalHandle for InfHandle {
3069 type View = InfView;
3070 fn node_id(&self) -> CstNodeId {
3071 self.0
3072 }
3073 fn new_with_visit<F: CstFacade, E>(
3074 index: CstNodeId,
3075 tree: &F,
3076 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3077 ) -> Result<Self, CstConstructError<E>> {
3078 tree.collect_nodes(
3079 index,
3080 [NodeKind::NonTerminal(NonTerminalKind::Inf)],
3081 |[index], visit| Ok((Self(index), visit)),
3082 visit_ignored,
3083 )
3084 }
3085 fn kind(&self) -> NonTerminalKind {
3086 NonTerminalKind::Inf
3087 }
3088 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3089 &self,
3090 tree: &F,
3091 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3092 visit_ignored: &'v mut V,
3093 ) -> Result<O, CstConstructError<E>> {
3094 tree.collect_nodes(
3095 self.0,
3096 [NodeKind::Terminal(TerminalKind::Inf)],
3097 |[inf], visit_ignored| Ok(visit(InfView { inf: Inf(inf) }, visit_ignored)),
3098 visit_ignored,
3099 )
3100 }
3101}
3102#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3103pub struct InfView {
3104 pub inf: Inf,
3105}
3106impl InfView {}
3107#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3108pub struct InlineCodeHandle(pub(crate) super::tree::CstNodeId);
3109impl NonTerminalHandle for InlineCodeHandle {
3110 type View = InlineCodeView;
3111 fn node_id(&self) -> CstNodeId {
3112 self.0
3113 }
3114 fn new_with_visit<F: CstFacade, E>(
3115 index: CstNodeId,
3116 tree: &F,
3117 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3118 ) -> Result<Self, CstConstructError<E>> {
3119 tree.collect_nodes(
3120 index,
3121 [NodeKind::NonTerminal(NonTerminalKind::InlineCode)],
3122 |[index], visit| Ok((Self(index), visit)),
3123 visit_ignored,
3124 )
3125 }
3126 fn kind(&self) -> NonTerminalKind {
3127 NonTerminalKind::InlineCode
3128 }
3129 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3130 &self,
3131 tree: &F,
3132 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3133 visit_ignored: &'v mut V,
3134 ) -> Result<O, CstConstructError<E>> {
3135 let mut children = tree.children(self.0);
3136 let Some(child) = children.next() else {
3137 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3138 };
3139 let Some(child_data) = tree.node_data(child) else {
3140 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3141 };
3142 let variant = match child_data.node_kind() {
3143 NodeKind::NonTerminal(NonTerminalKind::InlineCode2) => {
3144 InlineCodeView::InlineCode2(InlineCode2Handle(child))
3145 }
3146 NodeKind::NonTerminal(NonTerminalKind::InlineCode1) => {
3147 InlineCodeView::InlineCode1(InlineCode1Handle(child))
3148 }
3149 _ => {
3150 return Err(ViewConstructionError::UnexpectedNode {
3151 node: child,
3152 data: child_data,
3153 expected_kind: child_data.node_kind(),
3154 });
3155 }
3156 };
3157 let (result, _visit) = visit(variant, visit_ignored);
3158 if let Some(extra_child) = children.next() {
3159 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3160 }
3161 Ok(result)
3162 }
3163}
3164#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3165pub enum InlineCodeView {
3166 InlineCode2(InlineCode2Handle),
3167 InlineCode1(InlineCode1Handle),
3168}
3169impl InlineCodeView {}
3170#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3171pub struct InlineCode1Handle(pub(crate) super::tree::CstNodeId);
3172impl NonTerminalHandle for InlineCode1Handle {
3173 type View = InlineCode1View;
3174 fn node_id(&self) -> CstNodeId {
3175 self.0
3176 }
3177 fn new_with_visit<F: CstFacade, E>(
3178 index: CstNodeId,
3179 tree: &F,
3180 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3181 ) -> Result<Self, CstConstructError<E>> {
3182 tree.collect_nodes(
3183 index,
3184 [NodeKind::NonTerminal(NonTerminalKind::InlineCode1)],
3185 |[index], visit| Ok((Self(index), visit)),
3186 visit_ignored,
3187 )
3188 }
3189 fn kind(&self) -> NonTerminalKind {
3190 NonTerminalKind::InlineCode1
3191 }
3192 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3193 &self,
3194 tree: &F,
3195 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3196 visit_ignored: &'v mut V,
3197 ) -> Result<O, CstConstructError<E>> {
3198 tree.collect_nodes(
3199 self.0,
3200 [NodeKind::Terminal(TerminalKind::InlineCode1)],
3201 |[inline_code_1], visit_ignored| {
3202 Ok(visit(
3203 InlineCode1View {
3204 inline_code_1: InlineCode1(inline_code_1),
3205 },
3206 visit_ignored,
3207 ))
3208 },
3209 visit_ignored,
3210 )
3211 }
3212}
3213#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3214pub struct InlineCode1View {
3215 pub inline_code_1: InlineCode1,
3216}
3217impl InlineCode1View {}
3218#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3219pub struct InlineCode2Handle(pub(crate) super::tree::CstNodeId);
3220impl NonTerminalHandle for InlineCode2Handle {
3221 type View = InlineCode2View;
3222 fn node_id(&self) -> CstNodeId {
3223 self.0
3224 }
3225 fn new_with_visit<F: CstFacade, E>(
3226 index: CstNodeId,
3227 tree: &F,
3228 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3229 ) -> Result<Self, CstConstructError<E>> {
3230 tree.collect_nodes(
3231 index,
3232 [NodeKind::NonTerminal(NonTerminalKind::InlineCode2)],
3233 |[index], visit| Ok((Self(index), visit)),
3234 visit_ignored,
3235 )
3236 }
3237 fn kind(&self) -> NonTerminalKind {
3238 NonTerminalKind::InlineCode2
3239 }
3240 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3241 &self,
3242 tree: &F,
3243 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3244 visit_ignored: &'v mut V,
3245 ) -> Result<O, CstConstructError<E>> {
3246 tree.collect_nodes(
3247 self.0,
3248 [
3249 NodeKind::NonTerminal(NonTerminalKind::InlineCodeStart2),
3250 NodeKind::NonTerminal(NonTerminalKind::InlineCode2List),
3251 NodeKind::NonTerminal(NonTerminalKind::InlineCodeEnd2),
3252 ],
3253 |[inline_code_start_2, inline_code_2_list, inline_code_end_2], visit_ignored| {
3254 Ok(visit(
3255 InlineCode2View {
3256 inline_code_start_2: InlineCodeStart2Handle(inline_code_start_2),
3257 inline_code_2_list: InlineCode2ListHandle(inline_code_2_list),
3258 inline_code_end_2: InlineCodeEnd2Handle(inline_code_end_2),
3259 },
3260 visit_ignored,
3261 ))
3262 },
3263 visit_ignored,
3264 )
3265 }
3266}
3267#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3268pub struct InlineCode2View {
3269 pub inline_code_start_2: InlineCodeStart2Handle,
3270 pub inline_code_2_list: InlineCode2ListHandle,
3271 pub inline_code_end_2: InlineCodeEnd2Handle,
3272}
3273impl InlineCode2View {}
3274#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3275pub struct InlineCode2ListHandle(pub(crate) super::tree::CstNodeId);
3276impl NonTerminalHandle for InlineCode2ListHandle {
3277 type View = Option<InlineCode2ListView>;
3278 fn node_id(&self) -> CstNodeId {
3279 self.0
3280 }
3281 fn new_with_visit<F: CstFacade, E>(
3282 index: CstNodeId,
3283 tree: &F,
3284 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3285 ) -> Result<Self, CstConstructError<E>> {
3286 tree.collect_nodes(
3287 index,
3288 [NodeKind::NonTerminal(NonTerminalKind::InlineCode2List)],
3289 |[index], visit| Ok((Self(index), visit)),
3290 visit_ignored,
3291 )
3292 }
3293 fn kind(&self) -> NonTerminalKind {
3294 NonTerminalKind::InlineCode2List
3295 }
3296 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3297 &self,
3298 tree: &F,
3299 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3300 visit_ignored: &'v mut V,
3301 ) -> Result<O, CstConstructError<E>> {
3302 if tree.has_no_children(self.0) {
3303 return Ok(visit(None, visit_ignored).0);
3304 }
3305 tree.collect_nodes(
3306 self.0,
3307 [
3308 NodeKind::NonTerminal(NonTerminalKind::InlineCode2ListGroup),
3309 NodeKind::NonTerminal(NonTerminalKind::InlineCode2List),
3310 ],
3311 |[inline_code_2_list_group, inline_code_2_list], visit_ignored| {
3312 Ok(visit(
3313 Some(InlineCode2ListView {
3314 inline_code_2_list_group: InlineCode2ListGroupHandle(
3315 inline_code_2_list_group,
3316 ),
3317 inline_code_2_list: InlineCode2ListHandle(inline_code_2_list),
3318 }),
3319 visit_ignored,
3320 ))
3321 },
3322 visit_ignored,
3323 )
3324 }
3325}
3326#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3327pub struct InlineCode2ListView {
3328 pub inline_code_2_list_group: InlineCode2ListGroupHandle,
3329 pub inline_code_2_list: InlineCode2ListHandle,
3330}
3331impl<F: CstFacade> RecursiveView<F> for InlineCode2ListView {
3332 type Item = InlineCode2ListGroupHandle;
3333 fn get_all_with_visit<E>(
3334 &self,
3335 tree: &F,
3336 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3337 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
3338 let mut items = Vec::new();
3339 let mut current_view = Some(*self);
3340 while let Some(item) = current_view {
3341 let Self {
3342 inline_code_2_list_group,
3343 ..
3344 } = item;
3345 items.push(inline_code_2_list_group);
3346 item.inline_code_2_list.get_view_with_visit(
3347 tree,
3348 |view, visit_ignored| {
3349 current_view = view;
3350 ((), visit_ignored)
3351 },
3352 visit_ignored,
3353 )?;
3354 }
3355 Ok(items)
3356 }
3357}
3358#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3359pub struct InlineCode2ListGroupHandle(pub(crate) super::tree::CstNodeId);
3360impl NonTerminalHandle for InlineCode2ListGroupHandle {
3361 type View = InlineCode2ListGroupView;
3362 fn node_id(&self) -> CstNodeId {
3363 self.0
3364 }
3365 fn new_with_visit<F: CstFacade, E>(
3366 index: CstNodeId,
3367 tree: &F,
3368 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3369 ) -> Result<Self, CstConstructError<E>> {
3370 tree.collect_nodes(
3371 index,
3372 [NodeKind::NonTerminal(NonTerminalKind::InlineCode2ListGroup)],
3373 |[index], visit| Ok((Self(index), visit)),
3374 visit_ignored,
3375 )
3376 }
3377 fn kind(&self) -> NonTerminalKind {
3378 NonTerminalKind::InlineCode2ListGroup
3379 }
3380 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3381 &self,
3382 tree: &F,
3383 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3384 visit_ignored: &'v mut V,
3385 ) -> Result<O, CstConstructError<E>> {
3386 let mut children = tree.children(self.0);
3387 let Some(child) = children.next() else {
3388 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3389 };
3390 let Some(child_data) = tree.node_data(child) else {
3391 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3392 };
3393 let variant = match child_data.node_kind() {
3394 NodeKind::NonTerminal(NonTerminalKind::NoBacktickInline) => {
3395 InlineCode2ListGroupView::NoBacktickInline(NoBacktickInlineHandle(child))
3396 }
3397 NodeKind::NonTerminal(NonTerminalKind::Backtick1) => {
3398 InlineCode2ListGroupView::Backtick1(Backtick1Handle(child))
3399 }
3400 _ => {
3401 return Err(ViewConstructionError::UnexpectedNode {
3402 node: child,
3403 data: child_data,
3404 expected_kind: child_data.node_kind(),
3405 });
3406 }
3407 };
3408 let (result, _visit) = visit(variant, visit_ignored);
3409 if let Some(extra_child) = children.next() {
3410 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3411 }
3412 Ok(result)
3413 }
3414}
3415#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3416pub enum InlineCode2ListGroupView {
3417 NoBacktickInline(NoBacktickInlineHandle),
3418 Backtick1(Backtick1Handle),
3419}
3420impl InlineCode2ListGroupView {}
3421#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3422pub struct InlineCodeEnd2Handle(pub(crate) super::tree::CstNodeId);
3423impl NonTerminalHandle for InlineCodeEnd2Handle {
3424 type View = InlineCodeEnd2View;
3425 fn node_id(&self) -> CstNodeId {
3426 self.0
3427 }
3428 fn new_with_visit<F: CstFacade, E>(
3429 index: CstNodeId,
3430 tree: &F,
3431 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3432 ) -> Result<Self, CstConstructError<E>> {
3433 tree.collect_nodes(
3434 index,
3435 [NodeKind::NonTerminal(NonTerminalKind::InlineCodeEnd2)],
3436 |[index], visit| Ok((Self(index), visit)),
3437 visit_ignored,
3438 )
3439 }
3440 fn kind(&self) -> NonTerminalKind {
3441 NonTerminalKind::InlineCodeEnd2
3442 }
3443 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3444 &self,
3445 tree: &F,
3446 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3447 visit_ignored: &'v mut V,
3448 ) -> Result<O, CstConstructError<E>> {
3449 tree.collect_nodes(
3450 self.0,
3451 [NodeKind::Terminal(TerminalKind::InlineCodeEnd2)],
3452 |[inline_code_end_2], visit_ignored| {
3453 Ok(visit(
3454 InlineCodeEnd2View {
3455 inline_code_end_2: InlineCodeEnd2(inline_code_end_2),
3456 },
3457 visit_ignored,
3458 ))
3459 },
3460 visit_ignored,
3461 )
3462 }
3463}
3464#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3465pub struct InlineCodeEnd2View {
3466 pub inline_code_end_2: InlineCodeEnd2,
3467}
3468impl InlineCodeEnd2View {}
3469#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3470pub struct InlineCodeStart2Handle(pub(crate) super::tree::CstNodeId);
3471impl NonTerminalHandle for InlineCodeStart2Handle {
3472 type View = InlineCodeStart2View;
3473 fn node_id(&self) -> CstNodeId {
3474 self.0
3475 }
3476 fn new_with_visit<F: CstFacade, E>(
3477 index: CstNodeId,
3478 tree: &F,
3479 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3480 ) -> Result<Self, CstConstructError<E>> {
3481 tree.collect_nodes(
3482 index,
3483 [NodeKind::NonTerminal(NonTerminalKind::InlineCodeStart2)],
3484 |[index], visit| Ok((Self(index), visit)),
3485 visit_ignored,
3486 )
3487 }
3488 fn kind(&self) -> NonTerminalKind {
3489 NonTerminalKind::InlineCodeStart2
3490 }
3491 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3492 &self,
3493 tree: &F,
3494 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3495 visit_ignored: &'v mut V,
3496 ) -> Result<O, CstConstructError<E>> {
3497 tree.collect_nodes(
3498 self.0,
3499 [NodeKind::Terminal(TerminalKind::InlineCodeStart2)],
3500 |[inline_code_start_2], visit_ignored| {
3501 Ok(visit(
3502 InlineCodeStart2View {
3503 inline_code_start_2: InlineCodeStart2(inline_code_start_2),
3504 },
3505 visit_ignored,
3506 ))
3507 },
3508 visit_ignored,
3509 )
3510 }
3511}
3512#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3513pub struct InlineCodeStart2View {
3514 pub inline_code_start_2: InlineCodeStart2,
3515}
3516impl InlineCodeStart2View {}
3517#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3518pub struct IntegerHandle(pub(crate) super::tree::CstNodeId);
3519impl NonTerminalHandle for IntegerHandle {
3520 type View = IntegerView;
3521 fn node_id(&self) -> CstNodeId {
3522 self.0
3523 }
3524 fn new_with_visit<F: CstFacade, E>(
3525 index: CstNodeId,
3526 tree: &F,
3527 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3528 ) -> Result<Self, CstConstructError<E>> {
3529 tree.collect_nodes(
3530 index,
3531 [NodeKind::NonTerminal(NonTerminalKind::Integer)],
3532 |[index], visit| Ok((Self(index), visit)),
3533 visit_ignored,
3534 )
3535 }
3536 fn kind(&self) -> NonTerminalKind {
3537 NonTerminalKind::Integer
3538 }
3539 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3540 &self,
3541 tree: &F,
3542 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3543 visit_ignored: &'v mut V,
3544 ) -> Result<O, CstConstructError<E>> {
3545 tree.collect_nodes(
3546 self.0,
3547 [NodeKind::Terminal(TerminalKind::Integer)],
3548 |[integer], visit_ignored| {
3549 Ok(visit(
3550 IntegerView {
3551 integer: Integer(integer),
3552 },
3553 visit_ignored,
3554 ))
3555 },
3556 visit_ignored,
3557 )
3558 }
3559}
3560#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3561pub struct IntegerView {
3562 pub integer: Integer,
3563}
3564impl IntegerView {}
3565#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3566pub struct KeyHandle(pub(crate) super::tree::CstNodeId);
3567impl NonTerminalHandle for KeyHandle {
3568 type View = KeyView;
3569 fn node_id(&self) -> CstNodeId {
3570 self.0
3571 }
3572 fn new_with_visit<F: CstFacade, E>(
3573 index: CstNodeId,
3574 tree: &F,
3575 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3576 ) -> Result<Self, CstConstructError<E>> {
3577 tree.collect_nodes(
3578 index,
3579 [NodeKind::NonTerminal(NonTerminalKind::Key)],
3580 |[index], visit| Ok((Self(index), visit)),
3581 visit_ignored,
3582 )
3583 }
3584 fn kind(&self) -> NonTerminalKind {
3585 NonTerminalKind::Key
3586 }
3587 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3588 &self,
3589 tree: &F,
3590 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3591 visit_ignored: &'v mut V,
3592 ) -> Result<O, CstConstructError<E>> {
3593 tree.collect_nodes(
3594 self.0,
3595 [
3596 NodeKind::NonTerminal(NonTerminalKind::KeyBase),
3597 NodeKind::NonTerminal(NonTerminalKind::KeyOpt),
3598 ],
3599 |[key_base, key_opt], visit_ignored| {
3600 Ok(visit(
3601 KeyView {
3602 key_base: KeyBaseHandle(key_base),
3603 key_opt: KeyOptHandle(key_opt),
3604 },
3605 visit_ignored,
3606 ))
3607 },
3608 visit_ignored,
3609 )
3610 }
3611}
3612#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3613pub struct KeyView {
3614 pub key_base: KeyBaseHandle,
3615 pub key_opt: KeyOptHandle,
3616}
3617impl KeyView {}
3618#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3619pub struct KeyBaseHandle(pub(crate) super::tree::CstNodeId);
3620impl NonTerminalHandle for KeyBaseHandle {
3621 type View = KeyBaseView;
3622 fn node_id(&self) -> CstNodeId {
3623 self.0
3624 }
3625 fn new_with_visit<F: CstFacade, E>(
3626 index: CstNodeId,
3627 tree: &F,
3628 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3629 ) -> Result<Self, CstConstructError<E>> {
3630 tree.collect_nodes(
3631 index,
3632 [NodeKind::NonTerminal(NonTerminalKind::KeyBase)],
3633 |[index], visit| Ok((Self(index), visit)),
3634 visit_ignored,
3635 )
3636 }
3637 fn kind(&self) -> NonTerminalKind {
3638 NonTerminalKind::KeyBase
3639 }
3640 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3641 &self,
3642 tree: &F,
3643 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3644 visit_ignored: &'v mut V,
3645 ) -> Result<O, CstConstructError<E>> {
3646 let mut children = tree.children(self.0);
3647 let Some(child) = children.next() else {
3648 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3649 };
3650 let Some(child_data) = tree.node_data(child) else {
3651 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3652 };
3653 let variant = match child_data.node_kind() {
3654 NodeKind::NonTerminal(NonTerminalKind::KeyIdent) => {
3655 KeyBaseView::KeyIdent(KeyIdentHandle(child))
3656 }
3657 NodeKind::NonTerminal(NonTerminalKind::ExtensionNameSpace) => {
3658 KeyBaseView::ExtensionNameSpace(ExtensionNameSpaceHandle(child))
3659 }
3660 NodeKind::NonTerminal(NonTerminalKind::Str) => KeyBaseView::Str(StrHandle(child)),
3661 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
3662 KeyBaseView::Integer(IntegerHandle(child))
3663 }
3664 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
3665 KeyBaseView::KeyTuple(KeyTupleHandle(child))
3666 }
3667 NodeKind::NonTerminal(NonTerminalKind::TupleIndex) => {
3668 KeyBaseView::TupleIndex(TupleIndexHandle(child))
3669 }
3670 _ => {
3671 return Err(ViewConstructionError::UnexpectedNode {
3672 node: child,
3673 data: child_data,
3674 expected_kind: child_data.node_kind(),
3675 });
3676 }
3677 };
3678 let (result, _visit) = visit(variant, visit_ignored);
3679 if let Some(extra_child) = children.next() {
3680 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3681 }
3682 Ok(result)
3683 }
3684}
3685#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3686pub enum KeyBaseView {
3687 KeyIdent(KeyIdentHandle),
3688 ExtensionNameSpace(ExtensionNameSpaceHandle),
3689 Str(StrHandle),
3690 Integer(IntegerHandle),
3691 KeyTuple(KeyTupleHandle),
3692 TupleIndex(TupleIndexHandle),
3693}
3694impl KeyBaseView {}
3695#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3696pub struct KeyIdentHandle(pub(crate) super::tree::CstNodeId);
3697impl NonTerminalHandle for KeyIdentHandle {
3698 type View = KeyIdentView;
3699 fn node_id(&self) -> CstNodeId {
3700 self.0
3701 }
3702 fn new_with_visit<F: CstFacade, E>(
3703 index: CstNodeId,
3704 tree: &F,
3705 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3706 ) -> Result<Self, CstConstructError<E>> {
3707 tree.collect_nodes(
3708 index,
3709 [NodeKind::NonTerminal(NonTerminalKind::KeyIdent)],
3710 |[index], visit| Ok((Self(index), visit)),
3711 visit_ignored,
3712 )
3713 }
3714 fn kind(&self) -> NonTerminalKind {
3715 NonTerminalKind::KeyIdent
3716 }
3717 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3718 &self,
3719 tree: &F,
3720 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3721 visit_ignored: &'v mut V,
3722 ) -> Result<O, CstConstructError<E>> {
3723 let mut children = tree.children(self.0);
3724 let Some(child) = children.next() else {
3725 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3726 };
3727 let Some(child_data) = tree.node_data(child) else {
3728 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3729 };
3730 let variant = match child_data.node_kind() {
3731 NodeKind::NonTerminal(NonTerminalKind::Ident) => {
3732 KeyIdentView::Ident(IdentHandle(child))
3733 }
3734 NodeKind::NonTerminal(NonTerminalKind::True) => KeyIdentView::True(TrueHandle(child)),
3735 NodeKind::NonTerminal(NonTerminalKind::False) => {
3736 KeyIdentView::False(FalseHandle(child))
3737 }
3738 NodeKind::NonTerminal(NonTerminalKind::Null) => KeyIdentView::Null(NullHandle(child)),
3739 _ => {
3740 return Err(ViewConstructionError::UnexpectedNode {
3741 node: child,
3742 data: child_data,
3743 expected_kind: child_data.node_kind(),
3744 });
3745 }
3746 };
3747 let (result, _visit) = visit(variant, visit_ignored);
3748 if let Some(extra_child) = children.next() {
3749 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3750 }
3751 Ok(result)
3752 }
3753}
3754#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3755pub enum KeyIdentView {
3756 Ident(IdentHandle),
3757 True(TrueHandle),
3758 False(FalseHandle),
3759 Null(NullHandle),
3760}
3761impl KeyIdentView {}
3762#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3763pub struct KeyOptHandle(pub(crate) super::tree::CstNodeId);
3764impl NonTerminalHandle for KeyOptHandle {
3765 type View = Option<ArrayMarkerHandle>;
3766 fn node_id(&self) -> CstNodeId {
3767 self.0
3768 }
3769 fn new_with_visit<F: CstFacade, E>(
3770 index: CstNodeId,
3771 tree: &F,
3772 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3773 ) -> Result<Self, CstConstructError<E>> {
3774 tree.collect_nodes(
3775 index,
3776 [NodeKind::NonTerminal(NonTerminalKind::KeyOpt)],
3777 |[index], visit| Ok((Self(index), visit)),
3778 visit_ignored,
3779 )
3780 }
3781 fn kind(&self) -> NonTerminalKind {
3782 NonTerminalKind::KeyOpt
3783 }
3784 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3785 &self,
3786 tree: &F,
3787 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3788 visit_ignored: &'v mut V,
3789 ) -> Result<O, CstConstructError<E>> {
3790 if tree.has_no_children(self.0) {
3791 return Ok(visit(None, visit_ignored).0);
3792 }
3793 Ok(visit(
3794 Some(ArrayMarkerHandle::new_with_visit(
3795 self.0,
3796 tree,
3797 visit_ignored,
3798 )?),
3799 visit_ignored,
3800 )
3801 .0)
3802 }
3803}
3804#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3805pub struct KeyTupleHandle(pub(crate) super::tree::CstNodeId);
3806impl NonTerminalHandle for KeyTupleHandle {
3807 type View = KeyTupleView;
3808 fn node_id(&self) -> CstNodeId {
3809 self.0
3810 }
3811 fn new_with_visit<F: CstFacade, E>(
3812 index: CstNodeId,
3813 tree: &F,
3814 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3815 ) -> Result<Self, CstConstructError<E>> {
3816 tree.collect_nodes(
3817 index,
3818 [NodeKind::NonTerminal(NonTerminalKind::KeyTuple)],
3819 |[index], visit| Ok((Self(index), visit)),
3820 visit_ignored,
3821 )
3822 }
3823 fn kind(&self) -> NonTerminalKind {
3824 NonTerminalKind::KeyTuple
3825 }
3826 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3827 &self,
3828 tree: &F,
3829 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3830 visit_ignored: &'v mut V,
3831 ) -> Result<O, CstConstructError<E>> {
3832 tree.collect_nodes(
3833 self.0,
3834 [
3835 NodeKind::NonTerminal(NonTerminalKind::LParen),
3836 NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt),
3837 NodeKind::NonTerminal(NonTerminalKind::RParen),
3838 ],
3839 |[l_paren, key_tuple_opt, r_paren], visit_ignored| {
3840 Ok(visit(
3841 KeyTupleView {
3842 l_paren: LParenHandle(l_paren),
3843 key_tuple_opt: KeyTupleOptHandle(key_tuple_opt),
3844 r_paren: RParenHandle(r_paren),
3845 },
3846 visit_ignored,
3847 ))
3848 },
3849 visit_ignored,
3850 )
3851 }
3852}
3853#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3854pub struct KeyTupleView {
3855 pub l_paren: LParenHandle,
3856 pub key_tuple_opt: KeyTupleOptHandle,
3857 pub r_paren: RParenHandle,
3858}
3859impl KeyTupleView {}
3860#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3861pub struct KeyTupleElementsHandle(pub(crate) super::tree::CstNodeId);
3862impl NonTerminalHandle for KeyTupleElementsHandle {
3863 type View = KeyTupleElementsView;
3864 fn node_id(&self) -> CstNodeId {
3865 self.0
3866 }
3867 fn new_with_visit<F: CstFacade, E>(
3868 index: CstNodeId,
3869 tree: &F,
3870 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3871 ) -> Result<Self, CstConstructError<E>> {
3872 tree.collect_nodes(
3873 index,
3874 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElements)],
3875 |[index], visit| Ok((Self(index), visit)),
3876 visit_ignored,
3877 )
3878 }
3879 fn kind(&self) -> NonTerminalKind {
3880 NonTerminalKind::KeyTupleElements
3881 }
3882 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3883 &self,
3884 tree: &F,
3885 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3886 visit_ignored: &'v mut V,
3887 ) -> Result<O, CstConstructError<E>> {
3888 tree.collect_nodes(
3889 self.0,
3890 [
3891 NodeKind::NonTerminal(NonTerminalKind::KeyValue),
3892 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt),
3893 ],
3894 |[key_value, key_tuple_elements_opt], visit_ignored| {
3895 Ok(visit(
3896 KeyTupleElementsView {
3897 key_value: KeyValueHandle(key_value),
3898 key_tuple_elements_opt: KeyTupleElementsOptHandle(key_tuple_elements_opt),
3899 },
3900 visit_ignored,
3901 ))
3902 },
3903 visit_ignored,
3904 )
3905 }
3906}
3907#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3908pub struct KeyTupleElementsView {
3909 pub key_value: KeyValueHandle,
3910 pub key_tuple_elements_opt: KeyTupleElementsOptHandle,
3911}
3912impl KeyTupleElementsView {}
3913#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3914pub struct KeyTupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
3915impl NonTerminalHandle for KeyTupleElementsOptHandle {
3916 type View = Option<KeyTupleElementsTailHandle>;
3917 fn node_id(&self) -> CstNodeId {
3918 self.0
3919 }
3920 fn new_with_visit<F: CstFacade, E>(
3921 index: CstNodeId,
3922 tree: &F,
3923 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3924 ) -> Result<Self, CstConstructError<E>> {
3925 tree.collect_nodes(
3926 index,
3927 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt)],
3928 |[index], visit| Ok((Self(index), visit)),
3929 visit_ignored,
3930 )
3931 }
3932 fn kind(&self) -> NonTerminalKind {
3933 NonTerminalKind::KeyTupleElementsOpt
3934 }
3935 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3936 &self,
3937 tree: &F,
3938 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3939 visit_ignored: &'v mut V,
3940 ) -> Result<O, CstConstructError<E>> {
3941 if tree.has_no_children(self.0) {
3942 return Ok(visit(None, visit_ignored).0);
3943 }
3944 Ok(visit(
3945 Some(KeyTupleElementsTailHandle::new_with_visit(
3946 self.0,
3947 tree,
3948 visit_ignored,
3949 )?),
3950 visit_ignored,
3951 )
3952 .0)
3953 }
3954}
3955#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3956pub struct KeyTupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
3957impl NonTerminalHandle for KeyTupleElementsTailHandle {
3958 type View = KeyTupleElementsTailView;
3959 fn node_id(&self) -> CstNodeId {
3960 self.0
3961 }
3962 fn new_with_visit<F: CstFacade, E>(
3963 index: CstNodeId,
3964 tree: &F,
3965 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3966 ) -> Result<Self, CstConstructError<E>> {
3967 tree.collect_nodes(
3968 index,
3969 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTail)],
3970 |[index], visit| Ok((Self(index), visit)),
3971 visit_ignored,
3972 )
3973 }
3974 fn kind(&self) -> NonTerminalKind {
3975 NonTerminalKind::KeyTupleElementsTail
3976 }
3977 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3978 &self,
3979 tree: &F,
3980 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3981 visit_ignored: &'v mut V,
3982 ) -> Result<O, CstConstructError<E>> {
3983 tree.collect_nodes(
3984 self.0,
3985 [
3986 NodeKind::NonTerminal(NonTerminalKind::Comma),
3987 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTailOpt),
3988 ],
3989 |[comma, key_tuple_elements_tail_opt], visit_ignored| {
3990 Ok(visit(
3991 KeyTupleElementsTailView {
3992 comma: CommaHandle(comma),
3993 key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle(
3994 key_tuple_elements_tail_opt,
3995 ),
3996 },
3997 visit_ignored,
3998 ))
3999 },
4000 visit_ignored,
4001 )
4002 }
4003}
4004#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4005pub struct KeyTupleElementsTailView {
4006 pub comma: CommaHandle,
4007 pub key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle,
4008}
4009impl KeyTupleElementsTailView {}
4010#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4011pub struct KeyTupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
4012impl NonTerminalHandle for KeyTupleElementsTailOptHandle {
4013 type View = Option<KeyTupleElementsHandle>;
4014 fn node_id(&self) -> CstNodeId {
4015 self.0
4016 }
4017 fn new_with_visit<F: CstFacade, E>(
4018 index: CstNodeId,
4019 tree: &F,
4020 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4021 ) -> Result<Self, CstConstructError<E>> {
4022 tree.collect_nodes(
4023 index,
4024 [NodeKind::NonTerminal(
4025 NonTerminalKind::KeyTupleElementsTailOpt,
4026 )],
4027 |[index], visit| Ok((Self(index), visit)),
4028 visit_ignored,
4029 )
4030 }
4031 fn kind(&self) -> NonTerminalKind {
4032 NonTerminalKind::KeyTupleElementsTailOpt
4033 }
4034 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4035 &self,
4036 tree: &F,
4037 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4038 visit_ignored: &'v mut V,
4039 ) -> Result<O, CstConstructError<E>> {
4040 if tree.has_no_children(self.0) {
4041 return Ok(visit(None, visit_ignored).0);
4042 }
4043 Ok(visit(
4044 Some(KeyTupleElementsHandle::new_with_visit(
4045 self.0,
4046 tree,
4047 visit_ignored,
4048 )?),
4049 visit_ignored,
4050 )
4051 .0)
4052 }
4053}
4054#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4055pub struct KeyTupleOptHandle(pub(crate) super::tree::CstNodeId);
4056impl NonTerminalHandle for KeyTupleOptHandle {
4057 type View = Option<KeyTupleElementsHandle>;
4058 fn node_id(&self) -> CstNodeId {
4059 self.0
4060 }
4061 fn new_with_visit<F: CstFacade, E>(
4062 index: CstNodeId,
4063 tree: &F,
4064 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4065 ) -> Result<Self, CstConstructError<E>> {
4066 tree.collect_nodes(
4067 index,
4068 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt)],
4069 |[index], visit| Ok((Self(index), visit)),
4070 visit_ignored,
4071 )
4072 }
4073 fn kind(&self) -> NonTerminalKind {
4074 NonTerminalKind::KeyTupleOpt
4075 }
4076 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4077 &self,
4078 tree: &F,
4079 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4080 visit_ignored: &'v mut V,
4081 ) -> Result<O, CstConstructError<E>> {
4082 if tree.has_no_children(self.0) {
4083 return Ok(visit(None, visit_ignored).0);
4084 }
4085 Ok(visit(
4086 Some(KeyTupleElementsHandle::new_with_visit(
4087 self.0,
4088 tree,
4089 visit_ignored,
4090 )?),
4091 visit_ignored,
4092 )
4093 .0)
4094 }
4095}
4096#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4097pub struct KeyValueHandle(pub(crate) super::tree::CstNodeId);
4098impl NonTerminalHandle for KeyValueHandle {
4099 type View = KeyValueView;
4100 fn node_id(&self) -> CstNodeId {
4101 self.0
4102 }
4103 fn new_with_visit<F: CstFacade, E>(
4104 index: CstNodeId,
4105 tree: &F,
4106 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4107 ) -> Result<Self, CstConstructError<E>> {
4108 tree.collect_nodes(
4109 index,
4110 [NodeKind::NonTerminal(NonTerminalKind::KeyValue)],
4111 |[index], visit| Ok((Self(index), visit)),
4112 visit_ignored,
4113 )
4114 }
4115 fn kind(&self) -> NonTerminalKind {
4116 NonTerminalKind::KeyValue
4117 }
4118 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4119 &self,
4120 tree: &F,
4121 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4122 visit_ignored: &'v mut V,
4123 ) -> Result<O, CstConstructError<E>> {
4124 let mut children = tree.children(self.0);
4125 let Some(child) = children.next() else {
4126 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4127 };
4128 let Some(child_data) = tree.node_data(child) else {
4129 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4130 };
4131 let variant = match child_data.node_kind() {
4132 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
4133 KeyValueView::Integer(IntegerHandle(child))
4134 }
4135 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
4136 KeyValueView::Boolean(BooleanHandle(child))
4137 }
4138 NodeKind::NonTerminal(NonTerminalKind::Str) => KeyValueView::Str(StrHandle(child)),
4139 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
4140 KeyValueView::KeyTuple(KeyTupleHandle(child))
4141 }
4142 _ => {
4143 return Err(ViewConstructionError::UnexpectedNode {
4144 node: child,
4145 data: child_data,
4146 expected_kind: child_data.node_kind(),
4147 });
4148 }
4149 };
4150 let (result, _visit) = visit(variant, visit_ignored);
4151 if let Some(extra_child) = children.next() {
4152 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4153 }
4154 Ok(result)
4155 }
4156}
4157#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4158pub enum KeyValueView {
4159 Integer(IntegerHandle),
4160 Boolean(BooleanHandle),
4161 Str(StrHandle),
4162 KeyTuple(KeyTupleHandle),
4163}
4164impl KeyValueView {}
4165#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4166pub struct KeysHandle(pub(crate) super::tree::CstNodeId);
4167impl NonTerminalHandle for KeysHandle {
4168 type View = KeysView;
4169 fn node_id(&self) -> CstNodeId {
4170 self.0
4171 }
4172 fn new_with_visit<F: CstFacade, E>(
4173 index: CstNodeId,
4174 tree: &F,
4175 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4176 ) -> Result<Self, CstConstructError<E>> {
4177 tree.collect_nodes(
4178 index,
4179 [NodeKind::NonTerminal(NonTerminalKind::Keys)],
4180 |[index], visit| Ok((Self(index), visit)),
4181 visit_ignored,
4182 )
4183 }
4184 fn kind(&self) -> NonTerminalKind {
4185 NonTerminalKind::Keys
4186 }
4187 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4188 &self,
4189 tree: &F,
4190 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4191 visit_ignored: &'v mut V,
4192 ) -> Result<O, CstConstructError<E>> {
4193 tree.collect_nodes(
4194 self.0,
4195 [
4196 NodeKind::NonTerminal(NonTerminalKind::Key),
4197 NodeKind::NonTerminal(NonTerminalKind::KeysList),
4198 ],
4199 |[key, keys_list], visit_ignored| {
4200 Ok(visit(
4201 KeysView {
4202 key: KeyHandle(key),
4203 keys_list: KeysListHandle(keys_list),
4204 },
4205 visit_ignored,
4206 ))
4207 },
4208 visit_ignored,
4209 )
4210 }
4211}
4212#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4213pub struct KeysView {
4214 pub key: KeyHandle,
4215 pub keys_list: KeysListHandle,
4216}
4217impl KeysView {}
4218#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4219pub struct KeysListHandle(pub(crate) super::tree::CstNodeId);
4220impl NonTerminalHandle for KeysListHandle {
4221 type View = Option<KeysListView>;
4222 fn node_id(&self) -> CstNodeId {
4223 self.0
4224 }
4225 fn new_with_visit<F: CstFacade, E>(
4226 index: CstNodeId,
4227 tree: &F,
4228 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4229 ) -> Result<Self, CstConstructError<E>> {
4230 tree.collect_nodes(
4231 index,
4232 [NodeKind::NonTerminal(NonTerminalKind::KeysList)],
4233 |[index], visit| Ok((Self(index), visit)),
4234 visit_ignored,
4235 )
4236 }
4237 fn kind(&self) -> NonTerminalKind {
4238 NonTerminalKind::KeysList
4239 }
4240 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4241 &self,
4242 tree: &F,
4243 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4244 visit_ignored: &'v mut V,
4245 ) -> Result<O, CstConstructError<E>> {
4246 if tree.has_no_children(self.0) {
4247 return Ok(visit(None, visit_ignored).0);
4248 }
4249 tree.collect_nodes(
4250 self.0,
4251 [
4252 NodeKind::NonTerminal(NonTerminalKind::Dot),
4253 NodeKind::NonTerminal(NonTerminalKind::Key),
4254 NodeKind::NonTerminal(NonTerminalKind::KeysList),
4255 ],
4256 |[dot, key, keys_list], visit_ignored| {
4257 Ok(visit(
4258 Some(KeysListView {
4259 dot: DotHandle(dot),
4260 key: KeyHandle(key),
4261 keys_list: KeysListHandle(keys_list),
4262 }),
4263 visit_ignored,
4264 ))
4265 },
4266 visit_ignored,
4267 )
4268 }
4269}
4270#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4271pub struct KeysListView {
4272 pub dot: DotHandle,
4273 pub key: KeyHandle,
4274 pub keys_list: KeysListHandle,
4275}
4276impl<F: CstFacade> RecursiveView<F> for KeysListView {
4277 type Item = KeysListItem;
4278 fn get_all_with_visit<E>(
4279 &self,
4280 tree: &F,
4281 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4282 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
4283 let mut items = Vec::new();
4284 let mut current_view = Some(*self);
4285 while let Some(item) = current_view {
4286 let Self { dot, key, .. } = item;
4287 items.push(KeysListItem { dot, key });
4288 item.keys_list.get_view_with_visit(
4289 tree,
4290 |view, visit_ignored| {
4291 current_view = view;
4292 ((), visit_ignored)
4293 },
4294 visit_ignored,
4295 )?;
4296 }
4297 Ok(items)
4298 }
4299}
4300#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4301pub struct KeysListItem {
4302 pub dot: DotHandle,
4303 pub key: KeyHandle,
4304}
4305#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4306pub struct LParenHandle(pub(crate) super::tree::CstNodeId);
4307impl NonTerminalHandle for LParenHandle {
4308 type View = LParenView;
4309 fn node_id(&self) -> CstNodeId {
4310 self.0
4311 }
4312 fn new_with_visit<F: CstFacade, E>(
4313 index: CstNodeId,
4314 tree: &F,
4315 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4316 ) -> Result<Self, CstConstructError<E>> {
4317 tree.collect_nodes(
4318 index,
4319 [NodeKind::NonTerminal(NonTerminalKind::LParen)],
4320 |[index], visit| Ok((Self(index), visit)),
4321 visit_ignored,
4322 )
4323 }
4324 fn kind(&self) -> NonTerminalKind {
4325 NonTerminalKind::LParen
4326 }
4327 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4328 &self,
4329 tree: &F,
4330 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4331 visit_ignored: &'v mut V,
4332 ) -> Result<O, CstConstructError<E>> {
4333 tree.collect_nodes(
4334 self.0,
4335 [NodeKind::Terminal(TerminalKind::LParen)],
4336 |[l_paren], visit_ignored| {
4337 Ok(visit(
4338 LParenView {
4339 l_paren: LParen(l_paren),
4340 },
4341 visit_ignored,
4342 ))
4343 },
4344 visit_ignored,
4345 )
4346 }
4347}
4348#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4349pub struct LParenView {
4350 pub l_paren: LParen,
4351}
4352impl LParenView {}
4353#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4354pub struct MapBindHandle(pub(crate) super::tree::CstNodeId);
4355impl NonTerminalHandle for MapBindHandle {
4356 type View = MapBindView;
4357 fn node_id(&self) -> CstNodeId {
4358 self.0
4359 }
4360 fn new_with_visit<F: CstFacade, E>(
4361 index: CstNodeId,
4362 tree: &F,
4363 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4364 ) -> Result<Self, CstConstructError<E>> {
4365 tree.collect_nodes(
4366 index,
4367 [NodeKind::NonTerminal(NonTerminalKind::MapBind)],
4368 |[index], visit| Ok((Self(index), visit)),
4369 visit_ignored,
4370 )
4371 }
4372 fn kind(&self) -> NonTerminalKind {
4373 NonTerminalKind::MapBind
4374 }
4375 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4376 &self,
4377 tree: &F,
4378 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4379 visit_ignored: &'v mut V,
4380 ) -> Result<O, CstConstructError<E>> {
4381 tree.collect_nodes(
4382 self.0,
4383 [NodeKind::Terminal(TerminalKind::MapBind)],
4384 |[map_bind], visit_ignored| {
4385 Ok(visit(
4386 MapBindView {
4387 map_bind: MapBind(map_bind),
4388 },
4389 visit_ignored,
4390 ))
4391 },
4392 visit_ignored,
4393 )
4394 }
4395}
4396#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4397pub struct MapBindView {
4398 pub map_bind: MapBind,
4399}
4400impl MapBindView {}
4401#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4402pub struct NaNHandle(pub(crate) super::tree::CstNodeId);
4403impl NonTerminalHandle for NaNHandle {
4404 type View = NaNView;
4405 fn node_id(&self) -> CstNodeId {
4406 self.0
4407 }
4408 fn new_with_visit<F: CstFacade, E>(
4409 index: CstNodeId,
4410 tree: &F,
4411 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4412 ) -> Result<Self, CstConstructError<E>> {
4413 tree.collect_nodes(
4414 index,
4415 [NodeKind::NonTerminal(NonTerminalKind::NaN)],
4416 |[index], visit| Ok((Self(index), visit)),
4417 visit_ignored,
4418 )
4419 }
4420 fn kind(&self) -> NonTerminalKind {
4421 NonTerminalKind::NaN
4422 }
4423 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4424 &self,
4425 tree: &F,
4426 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4427 visit_ignored: &'v mut V,
4428 ) -> Result<O, CstConstructError<E>> {
4429 tree.collect_nodes(
4430 self.0,
4431 [NodeKind::Terminal(TerminalKind::NaN)],
4432 |[na_n], visit_ignored| Ok(visit(NaNView { na_n: NaN(na_n) }, visit_ignored)),
4433 visit_ignored,
4434 )
4435 }
4436}
4437#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4438pub struct NaNView {
4439 pub na_n: NaN,
4440}
4441impl NaNView {}
4442#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4443pub struct NoBacktickHandle(pub(crate) super::tree::CstNodeId);
4444impl NonTerminalHandle for NoBacktickHandle {
4445 type View = NoBacktickView;
4446 fn node_id(&self) -> CstNodeId {
4447 self.0
4448 }
4449 fn new_with_visit<F: CstFacade, E>(
4450 index: CstNodeId,
4451 tree: &F,
4452 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4453 ) -> Result<Self, CstConstructError<E>> {
4454 tree.collect_nodes(
4455 index,
4456 [NodeKind::NonTerminal(NonTerminalKind::NoBacktick)],
4457 |[index], visit| Ok((Self(index), visit)),
4458 visit_ignored,
4459 )
4460 }
4461 fn kind(&self) -> NonTerminalKind {
4462 NonTerminalKind::NoBacktick
4463 }
4464 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4465 &self,
4466 tree: &F,
4467 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4468 visit_ignored: &'v mut V,
4469 ) -> Result<O, CstConstructError<E>> {
4470 tree.collect_nodes(
4471 self.0,
4472 [NodeKind::Terminal(TerminalKind::NoBacktick)],
4473 |[no_backtick], visit_ignored| {
4474 Ok(visit(
4475 NoBacktickView {
4476 no_backtick: NoBacktick(no_backtick),
4477 },
4478 visit_ignored,
4479 ))
4480 },
4481 visit_ignored,
4482 )
4483 }
4484}
4485#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4486pub struct NoBacktickView {
4487 pub no_backtick: NoBacktick,
4488}
4489impl NoBacktickView {}
4490#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4491pub struct NoBacktickInlineHandle(pub(crate) super::tree::CstNodeId);
4492impl NonTerminalHandle for NoBacktickInlineHandle {
4493 type View = NoBacktickInlineView;
4494 fn node_id(&self) -> CstNodeId {
4495 self.0
4496 }
4497 fn new_with_visit<F: CstFacade, E>(
4498 index: CstNodeId,
4499 tree: &F,
4500 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4501 ) -> Result<Self, CstConstructError<E>> {
4502 tree.collect_nodes(
4503 index,
4504 [NodeKind::NonTerminal(NonTerminalKind::NoBacktickInline)],
4505 |[index], visit| Ok((Self(index), visit)),
4506 visit_ignored,
4507 )
4508 }
4509 fn kind(&self) -> NonTerminalKind {
4510 NonTerminalKind::NoBacktickInline
4511 }
4512 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4513 &self,
4514 tree: &F,
4515 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4516 visit_ignored: &'v mut V,
4517 ) -> Result<O, CstConstructError<E>> {
4518 tree.collect_nodes(
4519 self.0,
4520 [NodeKind::Terminal(TerminalKind::NoBacktickInline)],
4521 |[no_backtick_inline], visit_ignored| {
4522 Ok(visit(
4523 NoBacktickInlineView {
4524 no_backtick_inline: NoBacktickInline(no_backtick_inline),
4525 },
4526 visit_ignored,
4527 ))
4528 },
4529 visit_ignored,
4530 )
4531 }
4532}
4533#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4534pub struct NoBacktickInlineView {
4535 pub no_backtick_inline: NoBacktickInline,
4536}
4537impl NoBacktickInlineView {}
4538#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4539pub struct NullHandle(pub(crate) super::tree::CstNodeId);
4540impl NonTerminalHandle for NullHandle {
4541 type View = NullView;
4542 fn node_id(&self) -> CstNodeId {
4543 self.0
4544 }
4545 fn new_with_visit<F: CstFacade, E>(
4546 index: CstNodeId,
4547 tree: &F,
4548 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4549 ) -> Result<Self, CstConstructError<E>> {
4550 tree.collect_nodes(
4551 index,
4552 [NodeKind::NonTerminal(NonTerminalKind::Null)],
4553 |[index], visit| Ok((Self(index), visit)),
4554 visit_ignored,
4555 )
4556 }
4557 fn kind(&self) -> NonTerminalKind {
4558 NonTerminalKind::Null
4559 }
4560 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4561 &self,
4562 tree: &F,
4563 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4564 visit_ignored: &'v mut V,
4565 ) -> Result<O, CstConstructError<E>> {
4566 tree.collect_nodes(
4567 self.0,
4568 [NodeKind::Terminal(TerminalKind::Null)],
4569 |[null], visit_ignored| Ok(visit(NullView { null: Null(null) }, visit_ignored)),
4570 visit_ignored,
4571 )
4572 }
4573}
4574#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4575pub struct NullView {
4576 pub null: Null,
4577}
4578impl NullView {}
4579#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4580pub struct NumberHandle(pub(crate) super::tree::CstNodeId);
4581impl NonTerminalHandle for NumberHandle {
4582 type View = NumberView;
4583 fn node_id(&self) -> CstNodeId {
4584 self.0
4585 }
4586 fn new_with_visit<F: CstFacade, E>(
4587 index: CstNodeId,
4588 tree: &F,
4589 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4590 ) -> Result<Self, CstConstructError<E>> {
4591 tree.collect_nodes(
4592 index,
4593 [NodeKind::NonTerminal(NonTerminalKind::Number)],
4594 |[index], visit| Ok((Self(index), visit)),
4595 visit_ignored,
4596 )
4597 }
4598 fn kind(&self) -> NonTerminalKind {
4599 NonTerminalKind::Number
4600 }
4601 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4602 &self,
4603 tree: &F,
4604 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4605 visit_ignored: &'v mut V,
4606 ) -> Result<O, CstConstructError<E>> {
4607 let mut children = tree.children(self.0);
4608 let Some(child) = children.next() else {
4609 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4610 };
4611 let Some(child_data) = tree.node_data(child) else {
4612 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4613 };
4614 let variant = match child_data.node_kind() {
4615 NodeKind::NonTerminal(NonTerminalKind::Float) => NumberView::Float(FloatHandle(child)),
4616 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
4617 NumberView::Integer(IntegerHandle(child))
4618 }
4619 NodeKind::NonTerminal(NonTerminalKind::Inf) => NumberView::Inf(InfHandle(child)),
4620 NodeKind::NonTerminal(NonTerminalKind::NaN) => NumberView::NaN(NaNHandle(child)),
4621 _ => {
4622 return Err(ViewConstructionError::UnexpectedNode {
4623 node: child,
4624 data: child_data,
4625 expected_kind: child_data.node_kind(),
4626 });
4627 }
4628 };
4629 let (result, _visit) = visit(variant, visit_ignored);
4630 if let Some(extra_child) = children.next() {
4631 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4632 }
4633 Ok(result)
4634 }
4635}
4636#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4637pub enum NumberView {
4638 Float(FloatHandle),
4639 Integer(IntegerHandle),
4640 Inf(InfHandle),
4641 NaN(NaNHandle),
4642}
4643impl NumberView {}
4644#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4645pub struct ObjectHandle(pub(crate) super::tree::CstNodeId);
4646impl NonTerminalHandle for ObjectHandle {
4647 type View = ObjectView;
4648 fn node_id(&self) -> CstNodeId {
4649 self.0
4650 }
4651 fn new_with_visit<F: CstFacade, E>(
4652 index: CstNodeId,
4653 tree: &F,
4654 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4655 ) -> Result<Self, CstConstructError<E>> {
4656 tree.collect_nodes(
4657 index,
4658 [NodeKind::NonTerminal(NonTerminalKind::Object)],
4659 |[index], visit| Ok((Self(index), visit)),
4660 visit_ignored,
4661 )
4662 }
4663 fn kind(&self) -> NonTerminalKind {
4664 NonTerminalKind::Object
4665 }
4666 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4667 &self,
4668 tree: &F,
4669 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4670 visit_ignored: &'v mut V,
4671 ) -> Result<O, CstConstructError<E>> {
4672 tree.collect_nodes(
4673 self.0,
4674 [
4675 NodeKind::NonTerminal(NonTerminalKind::Begin),
4676 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt),
4677 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
4678 NodeKind::NonTerminal(NonTerminalKind::End),
4679 ],
4680 |[begin, object_opt, object_list, end], visit_ignored| {
4681 Ok(visit(
4682 ObjectView {
4683 begin: BeginHandle(begin),
4684 object_opt: ObjectOptHandle(object_opt),
4685 object_list: ObjectListHandle(object_list),
4686 end: EndHandle(end),
4687 },
4688 visit_ignored,
4689 ))
4690 },
4691 visit_ignored,
4692 )
4693 }
4694}
4695#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4696pub struct ObjectView {
4697 pub begin: BeginHandle,
4698 pub object_opt: ObjectOptHandle,
4699 pub object_list: ObjectListHandle,
4700 pub end: EndHandle,
4701}
4702impl ObjectView {}
4703#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4704pub struct ObjectListHandle(pub(crate) super::tree::CstNodeId);
4705impl NonTerminalHandle for ObjectListHandle {
4706 type View = Option<ObjectListView>;
4707 fn node_id(&self) -> CstNodeId {
4708 self.0
4709 }
4710 fn new_with_visit<F: CstFacade, E>(
4711 index: CstNodeId,
4712 tree: &F,
4713 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4714 ) -> Result<Self, CstConstructError<E>> {
4715 tree.collect_nodes(
4716 index,
4717 [NodeKind::NonTerminal(NonTerminalKind::ObjectList)],
4718 |[index], visit| Ok((Self(index), visit)),
4719 visit_ignored,
4720 )
4721 }
4722 fn kind(&self) -> NonTerminalKind {
4723 NonTerminalKind::ObjectList
4724 }
4725 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4726 &self,
4727 tree: &F,
4728 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4729 visit_ignored: &'v mut V,
4730 ) -> Result<O, CstConstructError<E>> {
4731 if tree.has_no_children(self.0) {
4732 return Ok(visit(None, visit_ignored).0);
4733 }
4734 tree.collect_nodes(
4735 self.0,
4736 [
4737 NodeKind::NonTerminal(NonTerminalKind::Keys),
4738 NodeKind::NonTerminal(NonTerminalKind::MapBind),
4739 NodeKind::NonTerminal(NonTerminalKind::Value),
4740 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0),
4741 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
4742 ],
4743 |[keys, map_bind, value, object_opt_0, object_list], visit_ignored| {
4744 Ok(visit(
4745 Some(ObjectListView {
4746 keys: KeysHandle(keys),
4747 map_bind: MapBindHandle(map_bind),
4748 value: ValueHandle(value),
4749 object_opt_0: ObjectOpt0Handle(object_opt_0),
4750 object_list: ObjectListHandle(object_list),
4751 }),
4752 visit_ignored,
4753 ))
4754 },
4755 visit_ignored,
4756 )
4757 }
4758}
4759#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4760pub struct ObjectListView {
4761 pub keys: KeysHandle,
4762 pub map_bind: MapBindHandle,
4763 pub value: ValueHandle,
4764 pub object_opt_0: ObjectOpt0Handle,
4765 pub object_list: ObjectListHandle,
4766}
4767impl<F: CstFacade> RecursiveView<F> for ObjectListView {
4768 type Item = ObjectListItem;
4769 fn get_all_with_visit<E>(
4770 &self,
4771 tree: &F,
4772 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4773 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
4774 let mut items = Vec::new();
4775 let mut current_view = Some(*self);
4776 while let Some(item) = current_view {
4777 let Self {
4778 keys,
4779 map_bind,
4780 value,
4781 object_opt_0,
4782 ..
4783 } = item;
4784 items.push(ObjectListItem {
4785 keys,
4786 map_bind,
4787 value,
4788 object_opt_0,
4789 });
4790 item.object_list.get_view_with_visit(
4791 tree,
4792 |view, visit_ignored| {
4793 current_view = view;
4794 ((), visit_ignored)
4795 },
4796 visit_ignored,
4797 )?;
4798 }
4799 Ok(items)
4800 }
4801}
4802#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4803pub struct ObjectListItem {
4804 pub keys: KeysHandle,
4805 pub map_bind: MapBindHandle,
4806 pub value: ValueHandle,
4807 pub object_opt_0: ObjectOpt0Handle,
4808}
4809#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4810pub struct ObjectOptHandle(pub(crate) super::tree::CstNodeId);
4811impl NonTerminalHandle for ObjectOptHandle {
4812 type View = Option<ObjectOptView>;
4813 fn node_id(&self) -> CstNodeId {
4814 self.0
4815 }
4816 fn new_with_visit<F: CstFacade, E>(
4817 index: CstNodeId,
4818 tree: &F,
4819 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4820 ) -> Result<Self, CstConstructError<E>> {
4821 tree.collect_nodes(
4822 index,
4823 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt)],
4824 |[index], visit| Ok((Self(index), visit)),
4825 visit_ignored,
4826 )
4827 }
4828 fn kind(&self) -> NonTerminalKind {
4829 NonTerminalKind::ObjectOpt
4830 }
4831 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4832 &self,
4833 tree: &F,
4834 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4835 visit_ignored: &'v mut V,
4836 ) -> Result<O, CstConstructError<E>> {
4837 if tree.has_no_children(self.0) {
4838 return Ok(visit(None, visit_ignored).0);
4839 }
4840 tree.collect_nodes(
4841 self.0,
4842 [
4843 NodeKind::NonTerminal(NonTerminalKind::ValueBinding),
4844 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1),
4845 ],
4846 |[value_binding, object_opt_1], visit_ignored| {
4847 Ok(visit(
4848 Some(ObjectOptView {
4849 value_binding: ValueBindingHandle(value_binding),
4850 object_opt_1: ObjectOpt1Handle(object_opt_1),
4851 }),
4852 visit_ignored,
4853 ))
4854 },
4855 visit_ignored,
4856 )
4857 }
4858}
4859#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4860pub struct ObjectOptView {
4861 pub value_binding: ValueBindingHandle,
4862 pub object_opt_1: ObjectOpt1Handle,
4863}
4864#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4865pub struct ObjectOpt0Handle(pub(crate) super::tree::CstNodeId);
4866impl NonTerminalHandle for ObjectOpt0Handle {
4867 type View = Option<CommaHandle>;
4868 fn node_id(&self) -> CstNodeId {
4869 self.0
4870 }
4871 fn new_with_visit<F: CstFacade, E>(
4872 index: CstNodeId,
4873 tree: &F,
4874 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4875 ) -> Result<Self, CstConstructError<E>> {
4876 tree.collect_nodes(
4877 index,
4878 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0)],
4879 |[index], visit| Ok((Self(index), visit)),
4880 visit_ignored,
4881 )
4882 }
4883 fn kind(&self) -> NonTerminalKind {
4884 NonTerminalKind::ObjectOpt0
4885 }
4886 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4887 &self,
4888 tree: &F,
4889 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4890 visit_ignored: &'v mut V,
4891 ) -> Result<O, CstConstructError<E>> {
4892 if tree.has_no_children(self.0) {
4893 return Ok(visit(None, visit_ignored).0);
4894 }
4895 Ok(visit(
4896 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
4897 visit_ignored,
4898 )
4899 .0)
4900 }
4901}
4902#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4903pub struct ObjectOpt1Handle(pub(crate) super::tree::CstNodeId);
4904impl NonTerminalHandle for ObjectOpt1Handle {
4905 type View = Option<CommaHandle>;
4906 fn node_id(&self) -> CstNodeId {
4907 self.0
4908 }
4909 fn new_with_visit<F: CstFacade, E>(
4910 index: CstNodeId,
4911 tree: &F,
4912 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4913 ) -> Result<Self, CstConstructError<E>> {
4914 tree.collect_nodes(
4915 index,
4916 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1)],
4917 |[index], visit| Ok((Self(index), visit)),
4918 visit_ignored,
4919 )
4920 }
4921 fn kind(&self) -> NonTerminalKind {
4922 NonTerminalKind::ObjectOpt1
4923 }
4924 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4925 &self,
4926 tree: &F,
4927 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4928 visit_ignored: &'v mut V,
4929 ) -> Result<O, CstConstructError<E>> {
4930 if tree.has_no_children(self.0) {
4931 return Ok(visit(None, visit_ignored).0);
4932 }
4933 Ok(visit(
4934 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
4935 visit_ignored,
4936 )
4937 .0)
4938 }
4939}
4940#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4941pub struct RParenHandle(pub(crate) super::tree::CstNodeId);
4942impl NonTerminalHandle for RParenHandle {
4943 type View = RParenView;
4944 fn node_id(&self) -> CstNodeId {
4945 self.0
4946 }
4947 fn new_with_visit<F: CstFacade, E>(
4948 index: CstNodeId,
4949 tree: &F,
4950 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4951 ) -> Result<Self, CstConstructError<E>> {
4952 tree.collect_nodes(
4953 index,
4954 [NodeKind::NonTerminal(NonTerminalKind::RParen)],
4955 |[index], visit| Ok((Self(index), visit)),
4956 visit_ignored,
4957 )
4958 }
4959 fn kind(&self) -> NonTerminalKind {
4960 NonTerminalKind::RParen
4961 }
4962 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4963 &self,
4964 tree: &F,
4965 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4966 visit_ignored: &'v mut V,
4967 ) -> Result<O, CstConstructError<E>> {
4968 tree.collect_nodes(
4969 self.0,
4970 [NodeKind::Terminal(TerminalKind::RParen)],
4971 |[r_paren], visit_ignored| {
4972 Ok(visit(
4973 RParenView {
4974 r_paren: RParen(r_paren),
4975 },
4976 visit_ignored,
4977 ))
4978 },
4979 visit_ignored,
4980 )
4981 }
4982}
4983#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4984pub struct RParenView {
4985 pub r_paren: RParen,
4986}
4987impl RParenView {}
4988#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4989pub struct SectionHandle(pub(crate) super::tree::CstNodeId);
4990impl NonTerminalHandle for SectionHandle {
4991 type View = SectionView;
4992 fn node_id(&self) -> CstNodeId {
4993 self.0
4994 }
4995 fn new_with_visit<F: CstFacade, E>(
4996 index: CstNodeId,
4997 tree: &F,
4998 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4999 ) -> Result<Self, CstConstructError<E>> {
5000 tree.collect_nodes(
5001 index,
5002 [NodeKind::NonTerminal(NonTerminalKind::Section)],
5003 |[index], visit| Ok((Self(index), visit)),
5004 visit_ignored,
5005 )
5006 }
5007 fn kind(&self) -> NonTerminalKind {
5008 NonTerminalKind::Section
5009 }
5010 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5011 &self,
5012 tree: &F,
5013 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5014 visit_ignored: &'v mut V,
5015 ) -> Result<O, CstConstructError<E>> {
5016 tree.collect_nodes(
5017 self.0,
5018 [
5019 NodeKind::NonTerminal(NonTerminalKind::At),
5020 NodeKind::NonTerminal(NonTerminalKind::Keys),
5021 NodeKind::NonTerminal(NonTerminalKind::SectionBody),
5022 ],
5023 |[at, keys, section_body], visit_ignored| {
5024 Ok(visit(
5025 SectionView {
5026 at: AtHandle(at),
5027 keys: KeysHandle(keys),
5028 section_body: SectionBodyHandle(section_body),
5029 },
5030 visit_ignored,
5031 ))
5032 },
5033 visit_ignored,
5034 )
5035 }
5036}
5037#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5038pub struct SectionView {
5039 pub at: AtHandle,
5040 pub keys: KeysHandle,
5041 pub section_body: SectionBodyHandle,
5042}
5043impl SectionView {}
5044#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5045pub struct SectionBindingHandle(pub(crate) super::tree::CstNodeId);
5046impl NonTerminalHandle for SectionBindingHandle {
5047 type View = SectionBindingView;
5048 fn node_id(&self) -> CstNodeId {
5049 self.0
5050 }
5051 fn new_with_visit<F: CstFacade, E>(
5052 index: CstNodeId,
5053 tree: &F,
5054 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5055 ) -> Result<Self, CstConstructError<E>> {
5056 tree.collect_nodes(
5057 index,
5058 [NodeKind::NonTerminal(NonTerminalKind::SectionBinding)],
5059 |[index], visit| Ok((Self(index), visit)),
5060 visit_ignored,
5061 )
5062 }
5063 fn kind(&self) -> NonTerminalKind {
5064 NonTerminalKind::SectionBinding
5065 }
5066 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5067 &self,
5068 tree: &F,
5069 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5070 visit_ignored: &'v mut V,
5071 ) -> Result<O, CstConstructError<E>> {
5072 tree.collect_nodes(
5073 self.0,
5074 [
5075 NodeKind::NonTerminal(NonTerminalKind::Begin),
5076 NodeKind::NonTerminal(NonTerminalKind::Eure),
5077 NodeKind::NonTerminal(NonTerminalKind::End),
5078 ],
5079 |[begin, eure, end], visit_ignored| {
5080 Ok(visit(
5081 SectionBindingView {
5082 begin: BeginHandle(begin),
5083 eure: EureHandle(eure),
5084 end: EndHandle(end),
5085 },
5086 visit_ignored,
5087 ))
5088 },
5089 visit_ignored,
5090 )
5091 }
5092}
5093#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5094pub struct SectionBindingView {
5095 pub begin: BeginHandle,
5096 pub eure: EureHandle,
5097 pub end: EndHandle,
5098}
5099impl SectionBindingView {}
5100#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5101pub struct SectionBodyHandle(pub(crate) super::tree::CstNodeId);
5102impl NonTerminalHandle for SectionBodyHandle {
5103 type View = SectionBodyView;
5104 fn node_id(&self) -> CstNodeId {
5105 self.0
5106 }
5107 fn new_with_visit<F: CstFacade, E>(
5108 index: CstNodeId,
5109 tree: &F,
5110 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5111 ) -> Result<Self, CstConstructError<E>> {
5112 tree.collect_nodes(
5113 index,
5114 [NodeKind::NonTerminal(NonTerminalKind::SectionBody)],
5115 |[index], visit| Ok((Self(index), visit)),
5116 visit_ignored,
5117 )
5118 }
5119 fn kind(&self) -> NonTerminalKind {
5120 NonTerminalKind::SectionBody
5121 }
5122 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5123 &self,
5124 tree: &F,
5125 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5126 visit_ignored: &'v mut V,
5127 ) -> Result<O, CstConstructError<E>> {
5128 let mut children = tree.children(self.0);
5129 let Some(child) = children.next() else {
5130 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5131 };
5132 let Some(child_data) = tree.node_data(child) else {
5133 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5134 };
5135 match child_data.node_kind() {
5136 NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt) => tree.collect_nodes(
5137 self.0,
5138 [
5139 NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt),
5140 NodeKind::NonTerminal(NonTerminalKind::SectionBodyList),
5141 ],
5142 |[section_body_opt, section_body_list], visit_ignored| {
5143 Ok(visit(
5144 SectionBodyView::Alt0(SectionBodyAlt0 {
5145 section_body_opt: SectionBodyOptHandle(section_body_opt),
5146 section_body_list: SectionBodyListHandle(section_body_list),
5147 }),
5148 visit_ignored,
5149 ))
5150 },
5151 visit_ignored,
5152 ),
5153 NodeKind::NonTerminal(NonTerminalKind::Begin) => tree.collect_nodes(
5154 self.0,
5155 [
5156 NodeKind::NonTerminal(NonTerminalKind::Begin),
5157 NodeKind::NonTerminal(NonTerminalKind::Eure),
5158 NodeKind::NonTerminal(NonTerminalKind::End),
5159 ],
5160 |[begin, eure, end], visit_ignored| {
5161 Ok(visit(
5162 SectionBodyView::Alt1(SectionBodyAlt1 {
5163 begin: BeginHandle(begin),
5164 eure: EureHandle(eure),
5165 end: EndHandle(end),
5166 }),
5167 visit_ignored,
5168 ))
5169 },
5170 visit_ignored,
5171 ),
5172 _ => Err(ViewConstructionError::UnexpectedNode {
5173 node: child,
5174 data: child_data,
5175 expected_kind: child_data.node_kind(),
5176 }),
5177 }
5178 }
5179}
5180#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5181pub enum SectionBodyView {
5182 Alt0(SectionBodyAlt0),
5183 Alt1(SectionBodyAlt1),
5184}
5185impl SectionBodyView {}
5186#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5187pub struct SectionBodyAlt0 {
5188 pub section_body_opt: SectionBodyOptHandle,
5189 pub section_body_list: SectionBodyListHandle,
5190}
5191#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5192pub struct SectionBodyAlt1 {
5193 pub begin: BeginHandle,
5194 pub eure: EureHandle,
5195 pub end: EndHandle,
5196}
5197#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5198pub struct SectionBodyListHandle(pub(crate) super::tree::CstNodeId);
5199impl NonTerminalHandle for SectionBodyListHandle {
5200 type View = Option<SectionBodyListView>;
5201 fn node_id(&self) -> CstNodeId {
5202 self.0
5203 }
5204 fn new_with_visit<F: CstFacade, E>(
5205 index: CstNodeId,
5206 tree: &F,
5207 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5208 ) -> Result<Self, CstConstructError<E>> {
5209 tree.collect_nodes(
5210 index,
5211 [NodeKind::NonTerminal(NonTerminalKind::SectionBodyList)],
5212 |[index], visit| Ok((Self(index), visit)),
5213 visit_ignored,
5214 )
5215 }
5216 fn kind(&self) -> NonTerminalKind {
5217 NonTerminalKind::SectionBodyList
5218 }
5219 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5220 &self,
5221 tree: &F,
5222 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5223 visit_ignored: &'v mut V,
5224 ) -> Result<O, CstConstructError<E>> {
5225 if tree.has_no_children(self.0) {
5226 return Ok(visit(None, visit_ignored).0);
5227 }
5228 tree.collect_nodes(
5229 self.0,
5230 [
5231 NodeKind::NonTerminal(NonTerminalKind::Binding),
5232 NodeKind::NonTerminal(NonTerminalKind::SectionBodyList),
5233 ],
5234 |[binding, section_body_list], visit_ignored| {
5235 Ok(visit(
5236 Some(SectionBodyListView {
5237 binding: BindingHandle(binding),
5238 section_body_list: SectionBodyListHandle(section_body_list),
5239 }),
5240 visit_ignored,
5241 ))
5242 },
5243 visit_ignored,
5244 )
5245 }
5246}
5247#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5248pub struct SectionBodyListView {
5249 pub binding: BindingHandle,
5250 pub section_body_list: SectionBodyListHandle,
5251}
5252impl<F: CstFacade> RecursiveView<F> for SectionBodyListView {
5253 type Item = BindingHandle;
5254 fn get_all_with_visit<E>(
5255 &self,
5256 tree: &F,
5257 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5258 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5259 let mut items = Vec::new();
5260 let mut current_view = Some(*self);
5261 while let Some(item) = current_view {
5262 let Self { binding, .. } = item;
5263 items.push(binding);
5264 item.section_body_list.get_view_with_visit(
5265 tree,
5266 |view, visit_ignored| {
5267 current_view = view;
5268 ((), visit_ignored)
5269 },
5270 visit_ignored,
5271 )?;
5272 }
5273 Ok(items)
5274 }
5275}
5276#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5277pub struct SectionBodyOptHandle(pub(crate) super::tree::CstNodeId);
5278impl NonTerminalHandle for SectionBodyOptHandle {
5279 type View = Option<ValueBindingHandle>;
5280 fn node_id(&self) -> CstNodeId {
5281 self.0
5282 }
5283 fn new_with_visit<F: CstFacade, E>(
5284 index: CstNodeId,
5285 tree: &F,
5286 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5287 ) -> Result<Self, CstConstructError<E>> {
5288 tree.collect_nodes(
5289 index,
5290 [NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt)],
5291 |[index], visit| Ok((Self(index), visit)),
5292 visit_ignored,
5293 )
5294 }
5295 fn kind(&self) -> NonTerminalKind {
5296 NonTerminalKind::SectionBodyOpt
5297 }
5298 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5299 &self,
5300 tree: &F,
5301 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5302 visit_ignored: &'v mut V,
5303 ) -> Result<O, CstConstructError<E>> {
5304 if tree.has_no_children(self.0) {
5305 return Ok(visit(None, visit_ignored).0);
5306 }
5307 Ok(visit(
5308 Some(ValueBindingHandle::new_with_visit(
5309 self.0,
5310 tree,
5311 visit_ignored,
5312 )?),
5313 visit_ignored,
5314 )
5315 .0)
5316 }
5317}
5318#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5319pub struct StrHandle(pub(crate) super::tree::CstNodeId);
5320impl NonTerminalHandle for StrHandle {
5321 type View = StrView;
5322 fn node_id(&self) -> CstNodeId {
5323 self.0
5324 }
5325 fn new_with_visit<F: CstFacade, E>(
5326 index: CstNodeId,
5327 tree: &F,
5328 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5329 ) -> Result<Self, CstConstructError<E>> {
5330 tree.collect_nodes(
5331 index,
5332 [NodeKind::NonTerminal(NonTerminalKind::Str)],
5333 |[index], visit| Ok((Self(index), visit)),
5334 visit_ignored,
5335 )
5336 }
5337 fn kind(&self) -> NonTerminalKind {
5338 NonTerminalKind::Str
5339 }
5340 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5341 &self,
5342 tree: &F,
5343 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5344 visit_ignored: &'v mut V,
5345 ) -> Result<O, CstConstructError<E>> {
5346 tree.collect_nodes(
5347 self.0,
5348 [NodeKind::Terminal(TerminalKind::Str)],
5349 |[str], visit_ignored| Ok(visit(StrView { str: Str(str) }, visit_ignored)),
5350 visit_ignored,
5351 )
5352 }
5353}
5354#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5355pub struct StrView {
5356 pub str: Str,
5357}
5358impl StrView {}
5359#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5360pub struct StringsHandle(pub(crate) super::tree::CstNodeId);
5361impl NonTerminalHandle for StringsHandle {
5362 type View = StringsView;
5363 fn node_id(&self) -> CstNodeId {
5364 self.0
5365 }
5366 fn new_with_visit<F: CstFacade, E>(
5367 index: CstNodeId,
5368 tree: &F,
5369 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5370 ) -> Result<Self, CstConstructError<E>> {
5371 tree.collect_nodes(
5372 index,
5373 [NodeKind::NonTerminal(NonTerminalKind::Strings)],
5374 |[index], visit| Ok((Self(index), visit)),
5375 visit_ignored,
5376 )
5377 }
5378 fn kind(&self) -> NonTerminalKind {
5379 NonTerminalKind::Strings
5380 }
5381 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5382 &self,
5383 tree: &F,
5384 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5385 visit_ignored: &'v mut V,
5386 ) -> Result<O, CstConstructError<E>> {
5387 tree.collect_nodes(
5388 self.0,
5389 [
5390 NodeKind::NonTerminal(NonTerminalKind::Str),
5391 NodeKind::NonTerminal(NonTerminalKind::StringsList),
5392 ],
5393 |[str, strings_list], visit_ignored| {
5394 Ok(visit(
5395 StringsView {
5396 str: StrHandle(str),
5397 strings_list: StringsListHandle(strings_list),
5398 },
5399 visit_ignored,
5400 ))
5401 },
5402 visit_ignored,
5403 )
5404 }
5405}
5406#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5407pub struct StringsView {
5408 pub str: StrHandle,
5409 pub strings_list: StringsListHandle,
5410}
5411impl StringsView {}
5412#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5413pub struct StringsListHandle(pub(crate) super::tree::CstNodeId);
5414impl NonTerminalHandle for StringsListHandle {
5415 type View = Option<StringsListView>;
5416 fn node_id(&self) -> CstNodeId {
5417 self.0
5418 }
5419 fn new_with_visit<F: CstFacade, E>(
5420 index: CstNodeId,
5421 tree: &F,
5422 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5423 ) -> Result<Self, CstConstructError<E>> {
5424 tree.collect_nodes(
5425 index,
5426 [NodeKind::NonTerminal(NonTerminalKind::StringsList)],
5427 |[index], visit| Ok((Self(index), visit)),
5428 visit_ignored,
5429 )
5430 }
5431 fn kind(&self) -> NonTerminalKind {
5432 NonTerminalKind::StringsList
5433 }
5434 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5435 &self,
5436 tree: &F,
5437 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5438 visit_ignored: &'v mut V,
5439 ) -> Result<O, CstConstructError<E>> {
5440 if tree.has_no_children(self.0) {
5441 return Ok(visit(None, visit_ignored).0);
5442 }
5443 tree.collect_nodes(
5444 self.0,
5445 [
5446 NodeKind::NonTerminal(NonTerminalKind::Continue),
5447 NodeKind::NonTerminal(NonTerminalKind::Str),
5448 NodeKind::NonTerminal(NonTerminalKind::StringsList),
5449 ],
5450 |[r#continue, str, strings_list], visit_ignored| {
5451 Ok(visit(
5452 Some(StringsListView {
5453 r#continue: ContinueHandle(r#continue),
5454 str: StrHandle(str),
5455 strings_list: StringsListHandle(strings_list),
5456 }),
5457 visit_ignored,
5458 ))
5459 },
5460 visit_ignored,
5461 )
5462 }
5463}
5464#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5465pub struct StringsListView {
5466 pub r#continue: ContinueHandle,
5467 pub str: StrHandle,
5468 pub strings_list: StringsListHandle,
5469}
5470impl<F: CstFacade> RecursiveView<F> for StringsListView {
5471 type Item = StringsListItem;
5472 fn get_all_with_visit<E>(
5473 &self,
5474 tree: &F,
5475 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5476 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5477 let mut items = Vec::new();
5478 let mut current_view = Some(*self);
5479 while let Some(item) = current_view {
5480 let Self {
5481 r#continue, str, ..
5482 } = item;
5483 items.push(StringsListItem { r#continue, str });
5484 item.strings_list.get_view_with_visit(
5485 tree,
5486 |view, visit_ignored| {
5487 current_view = view;
5488 ((), visit_ignored)
5489 },
5490 visit_ignored,
5491 )?;
5492 }
5493 Ok(items)
5494 }
5495}
5496#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5497pub struct StringsListItem {
5498 pub r#continue: ContinueHandle,
5499 pub str: StrHandle,
5500}
5501#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5502pub struct TextHandle(pub(crate) super::tree::CstNodeId);
5503impl NonTerminalHandle for TextHandle {
5504 type View = TextView;
5505 fn node_id(&self) -> CstNodeId {
5506 self.0
5507 }
5508 fn new_with_visit<F: CstFacade, E>(
5509 index: CstNodeId,
5510 tree: &F,
5511 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5512 ) -> Result<Self, CstConstructError<E>> {
5513 tree.collect_nodes(
5514 index,
5515 [NodeKind::NonTerminal(NonTerminalKind::Text)],
5516 |[index], visit| Ok((Self(index), visit)),
5517 visit_ignored,
5518 )
5519 }
5520 fn kind(&self) -> NonTerminalKind {
5521 NonTerminalKind::Text
5522 }
5523 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5524 &self,
5525 tree: &F,
5526 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5527 visit_ignored: &'v mut V,
5528 ) -> Result<O, CstConstructError<E>> {
5529 tree.collect_nodes(
5530 self.0,
5531 [NodeKind::Terminal(TerminalKind::Text)],
5532 |[text], visit_ignored| Ok(visit(TextView { text: Text(text) }, visit_ignored)),
5533 visit_ignored,
5534 )
5535 }
5536}
5537#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5538pub struct TextView {
5539 pub text: Text,
5540}
5541impl TextView {}
5542#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5543pub struct TextBindingHandle(pub(crate) super::tree::CstNodeId);
5544impl NonTerminalHandle for TextBindingHandle {
5545 type View = TextBindingView;
5546 fn node_id(&self) -> CstNodeId {
5547 self.0
5548 }
5549 fn new_with_visit<F: CstFacade, E>(
5550 index: CstNodeId,
5551 tree: &F,
5552 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5553 ) -> Result<Self, CstConstructError<E>> {
5554 tree.collect_nodes(
5555 index,
5556 [NodeKind::NonTerminal(NonTerminalKind::TextBinding)],
5557 |[index], visit| Ok((Self(index), visit)),
5558 visit_ignored,
5559 )
5560 }
5561 fn kind(&self) -> NonTerminalKind {
5562 NonTerminalKind::TextBinding
5563 }
5564 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5565 &self,
5566 tree: &F,
5567 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5568 visit_ignored: &'v mut V,
5569 ) -> Result<O, CstConstructError<E>> {
5570 tree.collect_nodes(
5571 self.0,
5572 [
5573 NodeKind::NonTerminal(NonTerminalKind::TextStart),
5574 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt),
5575 NodeKind::NonTerminal(NonTerminalKind::Text),
5576 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0),
5577 ],
5578 |[text_start, text_binding_opt, text, text_binding_opt_0], visit_ignored| {
5579 Ok(visit(
5580 TextBindingView {
5581 text_start: TextStartHandle(text_start),
5582 text_binding_opt: TextBindingOptHandle(text_binding_opt),
5583 text: TextHandle(text),
5584 text_binding_opt_0: TextBindingOpt0Handle(text_binding_opt_0),
5585 },
5586 visit_ignored,
5587 ))
5588 },
5589 visit_ignored,
5590 )
5591 }
5592}
5593#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5594pub struct TextBindingView {
5595 pub text_start: TextStartHandle,
5596 pub text_binding_opt: TextBindingOptHandle,
5597 pub text: TextHandle,
5598 pub text_binding_opt_0: TextBindingOpt0Handle,
5599}
5600impl TextBindingView {}
5601#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5602pub struct TextBindingOptHandle(pub(crate) super::tree::CstNodeId);
5603impl NonTerminalHandle for TextBindingOptHandle {
5604 type View = Option<WsHandle>;
5605 fn node_id(&self) -> CstNodeId {
5606 self.0
5607 }
5608 fn new_with_visit<F: CstFacade, E>(
5609 index: CstNodeId,
5610 tree: &F,
5611 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5612 ) -> Result<Self, CstConstructError<E>> {
5613 tree.collect_nodes(
5614 index,
5615 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt)],
5616 |[index], visit| Ok((Self(index), visit)),
5617 visit_ignored,
5618 )
5619 }
5620 fn kind(&self) -> NonTerminalKind {
5621 NonTerminalKind::TextBindingOpt
5622 }
5623 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5624 &self,
5625 tree: &F,
5626 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5627 visit_ignored: &'v mut V,
5628 ) -> Result<O, CstConstructError<E>> {
5629 if tree.has_no_children(self.0) {
5630 return Ok(visit(None, visit_ignored).0);
5631 }
5632 Ok(visit(
5633 Some(WsHandle::new_with_visit(self.0, tree, visit_ignored)?),
5634 visit_ignored,
5635 )
5636 .0)
5637 }
5638}
5639#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5640pub struct TextBindingOpt0Handle(pub(crate) super::tree::CstNodeId);
5641impl NonTerminalHandle for TextBindingOpt0Handle {
5642 type View = Option<GrammarNewlineHandle>;
5643 fn node_id(&self) -> CstNodeId {
5644 self.0
5645 }
5646 fn new_with_visit<F: CstFacade, E>(
5647 index: CstNodeId,
5648 tree: &F,
5649 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5650 ) -> Result<Self, CstConstructError<E>> {
5651 tree.collect_nodes(
5652 index,
5653 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0)],
5654 |[index], visit| Ok((Self(index), visit)),
5655 visit_ignored,
5656 )
5657 }
5658 fn kind(&self) -> NonTerminalKind {
5659 NonTerminalKind::TextBindingOpt0
5660 }
5661 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5662 &self,
5663 tree: &F,
5664 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5665 visit_ignored: &'v mut V,
5666 ) -> Result<O, CstConstructError<E>> {
5667 if tree.has_no_children(self.0) {
5668 return Ok(visit(None, visit_ignored).0);
5669 }
5670 Ok(visit(
5671 Some(GrammarNewlineHandle::new_with_visit(
5672 self.0,
5673 tree,
5674 visit_ignored,
5675 )?),
5676 visit_ignored,
5677 )
5678 .0)
5679 }
5680}
5681#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5682pub struct TextStartHandle(pub(crate) super::tree::CstNodeId);
5683impl NonTerminalHandle for TextStartHandle {
5684 type View = TextStartView;
5685 fn node_id(&self) -> CstNodeId {
5686 self.0
5687 }
5688 fn new_with_visit<F: CstFacade, E>(
5689 index: CstNodeId,
5690 tree: &F,
5691 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5692 ) -> Result<Self, CstConstructError<E>> {
5693 tree.collect_nodes(
5694 index,
5695 [NodeKind::NonTerminal(NonTerminalKind::TextStart)],
5696 |[index], visit| Ok((Self(index), visit)),
5697 visit_ignored,
5698 )
5699 }
5700 fn kind(&self) -> NonTerminalKind {
5701 NonTerminalKind::TextStart
5702 }
5703 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5704 &self,
5705 tree: &F,
5706 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5707 visit_ignored: &'v mut V,
5708 ) -> Result<O, CstConstructError<E>> {
5709 tree.collect_nodes(
5710 self.0,
5711 [NodeKind::Terminal(TerminalKind::TextStart)],
5712 |[text_start], visit_ignored| {
5713 Ok(visit(
5714 TextStartView {
5715 text_start: TextStart(text_start),
5716 },
5717 visit_ignored,
5718 ))
5719 },
5720 visit_ignored,
5721 )
5722 }
5723}
5724#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5725pub struct TextStartView {
5726 pub text_start: TextStart,
5727}
5728impl TextStartView {}
5729#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5730pub struct TrueHandle(pub(crate) super::tree::CstNodeId);
5731impl NonTerminalHandle for TrueHandle {
5732 type View = TrueView;
5733 fn node_id(&self) -> CstNodeId {
5734 self.0
5735 }
5736 fn new_with_visit<F: CstFacade, E>(
5737 index: CstNodeId,
5738 tree: &F,
5739 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5740 ) -> Result<Self, CstConstructError<E>> {
5741 tree.collect_nodes(
5742 index,
5743 [NodeKind::NonTerminal(NonTerminalKind::True)],
5744 |[index], visit| Ok((Self(index), visit)),
5745 visit_ignored,
5746 )
5747 }
5748 fn kind(&self) -> NonTerminalKind {
5749 NonTerminalKind::True
5750 }
5751 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5752 &self,
5753 tree: &F,
5754 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5755 visit_ignored: &'v mut V,
5756 ) -> Result<O, CstConstructError<E>> {
5757 tree.collect_nodes(
5758 self.0,
5759 [NodeKind::Terminal(TerminalKind::True)],
5760 |[r#true], visit_ignored| {
5761 Ok(visit(
5762 TrueView {
5763 r#true: True(r#true),
5764 },
5765 visit_ignored,
5766 ))
5767 },
5768 visit_ignored,
5769 )
5770 }
5771}
5772#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5773pub struct TrueView {
5774 pub r#true: True,
5775}
5776impl TrueView {}
5777#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5778pub struct TupleHandle(pub(crate) super::tree::CstNodeId);
5779impl NonTerminalHandle for TupleHandle {
5780 type View = TupleView;
5781 fn node_id(&self) -> CstNodeId {
5782 self.0
5783 }
5784 fn new_with_visit<F: CstFacade, E>(
5785 index: CstNodeId,
5786 tree: &F,
5787 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5788 ) -> Result<Self, CstConstructError<E>> {
5789 tree.collect_nodes(
5790 index,
5791 [NodeKind::NonTerminal(NonTerminalKind::Tuple)],
5792 |[index], visit| Ok((Self(index), visit)),
5793 visit_ignored,
5794 )
5795 }
5796 fn kind(&self) -> NonTerminalKind {
5797 NonTerminalKind::Tuple
5798 }
5799 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5800 &self,
5801 tree: &F,
5802 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5803 visit_ignored: &'v mut V,
5804 ) -> Result<O, CstConstructError<E>> {
5805 tree.collect_nodes(
5806 self.0,
5807 [
5808 NodeKind::NonTerminal(NonTerminalKind::LParen),
5809 NodeKind::NonTerminal(NonTerminalKind::TupleOpt),
5810 NodeKind::NonTerminal(NonTerminalKind::RParen),
5811 ],
5812 |[l_paren, tuple_opt, r_paren], visit_ignored| {
5813 Ok(visit(
5814 TupleView {
5815 l_paren: LParenHandle(l_paren),
5816 tuple_opt: TupleOptHandle(tuple_opt),
5817 r_paren: RParenHandle(r_paren),
5818 },
5819 visit_ignored,
5820 ))
5821 },
5822 visit_ignored,
5823 )
5824 }
5825}
5826#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5827pub struct TupleView {
5828 pub l_paren: LParenHandle,
5829 pub tuple_opt: TupleOptHandle,
5830 pub r_paren: RParenHandle,
5831}
5832impl TupleView {}
5833#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5834pub struct TupleElementsHandle(pub(crate) super::tree::CstNodeId);
5835impl NonTerminalHandle for TupleElementsHandle {
5836 type View = TupleElementsView;
5837 fn node_id(&self) -> CstNodeId {
5838 self.0
5839 }
5840 fn new_with_visit<F: CstFacade, E>(
5841 index: CstNodeId,
5842 tree: &F,
5843 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5844 ) -> Result<Self, CstConstructError<E>> {
5845 tree.collect_nodes(
5846 index,
5847 [NodeKind::NonTerminal(NonTerminalKind::TupleElements)],
5848 |[index], visit| Ok((Self(index), visit)),
5849 visit_ignored,
5850 )
5851 }
5852 fn kind(&self) -> NonTerminalKind {
5853 NonTerminalKind::TupleElements
5854 }
5855 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5856 &self,
5857 tree: &F,
5858 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5859 visit_ignored: &'v mut V,
5860 ) -> Result<O, CstConstructError<E>> {
5861 tree.collect_nodes(
5862 self.0,
5863 [
5864 NodeKind::NonTerminal(NonTerminalKind::Value),
5865 NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt),
5866 ],
5867 |[value, tuple_elements_opt], visit_ignored| {
5868 Ok(visit(
5869 TupleElementsView {
5870 value: ValueHandle(value),
5871 tuple_elements_opt: TupleElementsOptHandle(tuple_elements_opt),
5872 },
5873 visit_ignored,
5874 ))
5875 },
5876 visit_ignored,
5877 )
5878 }
5879}
5880#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5881pub struct TupleElementsView {
5882 pub value: ValueHandle,
5883 pub tuple_elements_opt: TupleElementsOptHandle,
5884}
5885impl TupleElementsView {}
5886#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5887pub struct TupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
5888impl NonTerminalHandle for TupleElementsOptHandle {
5889 type View = Option<TupleElementsTailHandle>;
5890 fn node_id(&self) -> CstNodeId {
5891 self.0
5892 }
5893 fn new_with_visit<F: CstFacade, E>(
5894 index: CstNodeId,
5895 tree: &F,
5896 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5897 ) -> Result<Self, CstConstructError<E>> {
5898 tree.collect_nodes(
5899 index,
5900 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt)],
5901 |[index], visit| Ok((Self(index), visit)),
5902 visit_ignored,
5903 )
5904 }
5905 fn kind(&self) -> NonTerminalKind {
5906 NonTerminalKind::TupleElementsOpt
5907 }
5908 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5909 &self,
5910 tree: &F,
5911 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5912 visit_ignored: &'v mut V,
5913 ) -> Result<O, CstConstructError<E>> {
5914 if tree.has_no_children(self.0) {
5915 return Ok(visit(None, visit_ignored).0);
5916 }
5917 Ok(visit(
5918 Some(TupleElementsTailHandle::new_with_visit(
5919 self.0,
5920 tree,
5921 visit_ignored,
5922 )?),
5923 visit_ignored,
5924 )
5925 .0)
5926 }
5927}
5928#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5929pub struct TupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
5930impl NonTerminalHandle for TupleElementsTailHandle {
5931 type View = TupleElementsTailView;
5932 fn node_id(&self) -> CstNodeId {
5933 self.0
5934 }
5935 fn new_with_visit<F: CstFacade, E>(
5936 index: CstNodeId,
5937 tree: &F,
5938 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5939 ) -> Result<Self, CstConstructError<E>> {
5940 tree.collect_nodes(
5941 index,
5942 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTail)],
5943 |[index], visit| Ok((Self(index), visit)),
5944 visit_ignored,
5945 )
5946 }
5947 fn kind(&self) -> NonTerminalKind {
5948 NonTerminalKind::TupleElementsTail
5949 }
5950 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5951 &self,
5952 tree: &F,
5953 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5954 visit_ignored: &'v mut V,
5955 ) -> Result<O, CstConstructError<E>> {
5956 tree.collect_nodes(
5957 self.0,
5958 [
5959 NodeKind::NonTerminal(NonTerminalKind::Comma),
5960 NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt),
5961 ],
5962 |[comma, tuple_elements_tail_opt], visit_ignored| {
5963 Ok(visit(
5964 TupleElementsTailView {
5965 comma: CommaHandle(comma),
5966 tuple_elements_tail_opt: TupleElementsTailOptHandle(
5967 tuple_elements_tail_opt,
5968 ),
5969 },
5970 visit_ignored,
5971 ))
5972 },
5973 visit_ignored,
5974 )
5975 }
5976}
5977#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5978pub struct TupleElementsTailView {
5979 pub comma: CommaHandle,
5980 pub tuple_elements_tail_opt: TupleElementsTailOptHandle,
5981}
5982impl TupleElementsTailView {}
5983#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5984pub struct TupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
5985impl NonTerminalHandle for TupleElementsTailOptHandle {
5986 type View = Option<TupleElementsHandle>;
5987 fn node_id(&self) -> CstNodeId {
5988 self.0
5989 }
5990 fn new_with_visit<F: CstFacade, E>(
5991 index: CstNodeId,
5992 tree: &F,
5993 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5994 ) -> Result<Self, CstConstructError<E>> {
5995 tree.collect_nodes(
5996 index,
5997 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt)],
5998 |[index], visit| Ok((Self(index), visit)),
5999 visit_ignored,
6000 )
6001 }
6002 fn kind(&self) -> NonTerminalKind {
6003 NonTerminalKind::TupleElementsTailOpt
6004 }
6005 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6006 &self,
6007 tree: &F,
6008 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6009 visit_ignored: &'v mut V,
6010 ) -> Result<O, CstConstructError<E>> {
6011 if tree.has_no_children(self.0) {
6012 return Ok(visit(None, visit_ignored).0);
6013 }
6014 Ok(visit(
6015 Some(TupleElementsHandle::new_with_visit(
6016 self.0,
6017 tree,
6018 visit_ignored,
6019 )?),
6020 visit_ignored,
6021 )
6022 .0)
6023 }
6024}
6025#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6026pub struct TupleIndexHandle(pub(crate) super::tree::CstNodeId);
6027impl NonTerminalHandle for TupleIndexHandle {
6028 type View = TupleIndexView;
6029 fn node_id(&self) -> CstNodeId {
6030 self.0
6031 }
6032 fn new_with_visit<F: CstFacade, E>(
6033 index: CstNodeId,
6034 tree: &F,
6035 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6036 ) -> Result<Self, CstConstructError<E>> {
6037 tree.collect_nodes(
6038 index,
6039 [NodeKind::NonTerminal(NonTerminalKind::TupleIndex)],
6040 |[index], visit| Ok((Self(index), visit)),
6041 visit_ignored,
6042 )
6043 }
6044 fn kind(&self) -> NonTerminalKind {
6045 NonTerminalKind::TupleIndex
6046 }
6047 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6048 &self,
6049 tree: &F,
6050 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6051 visit_ignored: &'v mut V,
6052 ) -> Result<O, CstConstructError<E>> {
6053 tree.collect_nodes(
6054 self.0,
6055 [
6056 NodeKind::Terminal(TerminalKind::Hash),
6057 NodeKind::NonTerminal(NonTerminalKind::Integer),
6058 ],
6059 |[hash, integer], visit_ignored| {
6060 Ok(visit(
6061 TupleIndexView {
6062 hash: Hash(hash),
6063 integer: IntegerHandle(integer),
6064 },
6065 visit_ignored,
6066 ))
6067 },
6068 visit_ignored,
6069 )
6070 }
6071}
6072#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6073pub struct TupleIndexView {
6074 pub hash: Hash,
6075 pub integer: IntegerHandle,
6076}
6077impl TupleIndexView {}
6078#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6079pub struct TupleOptHandle(pub(crate) super::tree::CstNodeId);
6080impl NonTerminalHandle for TupleOptHandle {
6081 type View = Option<TupleElementsHandle>;
6082 fn node_id(&self) -> CstNodeId {
6083 self.0
6084 }
6085 fn new_with_visit<F: CstFacade, E>(
6086 index: CstNodeId,
6087 tree: &F,
6088 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6089 ) -> Result<Self, CstConstructError<E>> {
6090 tree.collect_nodes(
6091 index,
6092 [NodeKind::NonTerminal(NonTerminalKind::TupleOpt)],
6093 |[index], visit| Ok((Self(index), visit)),
6094 visit_ignored,
6095 )
6096 }
6097 fn kind(&self) -> NonTerminalKind {
6098 NonTerminalKind::TupleOpt
6099 }
6100 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6101 &self,
6102 tree: &F,
6103 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6104 visit_ignored: &'v mut V,
6105 ) -> Result<O, CstConstructError<E>> {
6106 if tree.has_no_children(self.0) {
6107 return Ok(visit(None, visit_ignored).0);
6108 }
6109 Ok(visit(
6110 Some(TupleElementsHandle::new_with_visit(
6111 self.0,
6112 tree,
6113 visit_ignored,
6114 )?),
6115 visit_ignored,
6116 )
6117 .0)
6118 }
6119}
6120#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6121pub struct ValueHandle(pub(crate) super::tree::CstNodeId);
6122impl NonTerminalHandle for ValueHandle {
6123 type View = ValueView;
6124 fn node_id(&self) -> CstNodeId {
6125 self.0
6126 }
6127 fn new_with_visit<F: CstFacade, E>(
6128 index: CstNodeId,
6129 tree: &F,
6130 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6131 ) -> Result<Self, CstConstructError<E>> {
6132 tree.collect_nodes(
6133 index,
6134 [NodeKind::NonTerminal(NonTerminalKind::Value)],
6135 |[index], visit| Ok((Self(index), visit)),
6136 visit_ignored,
6137 )
6138 }
6139 fn kind(&self) -> NonTerminalKind {
6140 NonTerminalKind::Value
6141 }
6142 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6143 &self,
6144 tree: &F,
6145 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6146 visit_ignored: &'v mut V,
6147 ) -> Result<O, CstConstructError<E>> {
6148 let mut children = tree.children(self.0);
6149 let Some(child) = children.next() else {
6150 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6151 };
6152 let Some(child_data) = tree.node_data(child) else {
6153 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6154 };
6155 let variant = match child_data.node_kind() {
6156 NodeKind::NonTerminal(NonTerminalKind::Object) => {
6157 ValueView::Object(ObjectHandle(child))
6158 }
6159 NodeKind::NonTerminal(NonTerminalKind::Array) => ValueView::Array(ArrayHandle(child)),
6160 NodeKind::NonTerminal(NonTerminalKind::Tuple) => ValueView::Tuple(TupleHandle(child)),
6161 NodeKind::NonTerminal(NonTerminalKind::Number) => {
6162 ValueView::Number(NumberHandle(child))
6163 }
6164 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
6165 ValueView::Boolean(BooleanHandle(child))
6166 }
6167 NodeKind::NonTerminal(NonTerminalKind::Null) => ValueView::Null(NullHandle(child)),
6168 NodeKind::NonTerminal(NonTerminalKind::Strings) => {
6169 ValueView::Strings(StringsHandle(child))
6170 }
6171 NodeKind::NonTerminal(NonTerminalKind::Hole) => ValueView::Hole(HoleHandle(child)),
6172 NodeKind::NonTerminal(NonTerminalKind::CodeBlock) => {
6173 ValueView::CodeBlock(CodeBlockHandle(child))
6174 }
6175 NodeKind::NonTerminal(NonTerminalKind::InlineCode) => {
6176 ValueView::InlineCode(InlineCodeHandle(child))
6177 }
6178 _ => {
6179 return Err(ViewConstructionError::UnexpectedNode {
6180 node: child,
6181 data: child_data,
6182 expected_kind: child_data.node_kind(),
6183 });
6184 }
6185 };
6186 let (result, _visit) = visit(variant, visit_ignored);
6187 if let Some(extra_child) = children.next() {
6188 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6189 }
6190 Ok(result)
6191 }
6192}
6193#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6194pub enum ValueView {
6195 Object(ObjectHandle),
6196 Array(ArrayHandle),
6197 Tuple(TupleHandle),
6198 Number(NumberHandle),
6199 Boolean(BooleanHandle),
6200 Null(NullHandle),
6201 Strings(StringsHandle),
6202 Hole(HoleHandle),
6203 CodeBlock(CodeBlockHandle),
6204 InlineCode(InlineCodeHandle),
6205}
6206impl ValueView {}
6207#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6208pub struct ValueBindingHandle(pub(crate) super::tree::CstNodeId);
6209impl NonTerminalHandle for ValueBindingHandle {
6210 type View = ValueBindingView;
6211 fn node_id(&self) -> CstNodeId {
6212 self.0
6213 }
6214 fn new_with_visit<F: CstFacade, E>(
6215 index: CstNodeId,
6216 tree: &F,
6217 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6218 ) -> Result<Self, CstConstructError<E>> {
6219 tree.collect_nodes(
6220 index,
6221 [NodeKind::NonTerminal(NonTerminalKind::ValueBinding)],
6222 |[index], visit| Ok((Self(index), visit)),
6223 visit_ignored,
6224 )
6225 }
6226 fn kind(&self) -> NonTerminalKind {
6227 NonTerminalKind::ValueBinding
6228 }
6229 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6230 &self,
6231 tree: &F,
6232 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6233 visit_ignored: &'v mut V,
6234 ) -> Result<O, CstConstructError<E>> {
6235 tree.collect_nodes(
6236 self.0,
6237 [
6238 NodeKind::NonTerminal(NonTerminalKind::Bind),
6239 NodeKind::NonTerminal(NonTerminalKind::Value),
6240 ],
6241 |[bind, value], visit_ignored| {
6242 Ok(visit(
6243 ValueBindingView {
6244 bind: BindHandle(bind),
6245 value: ValueHandle(value),
6246 },
6247 visit_ignored,
6248 ))
6249 },
6250 visit_ignored,
6251 )
6252 }
6253}
6254#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6255pub struct ValueBindingView {
6256 pub bind: BindHandle,
6257 pub value: ValueHandle,
6258}
6259impl ValueBindingView {}
6260#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6261pub struct WsHandle(pub(crate) super::tree::CstNodeId);
6262impl NonTerminalHandle for WsHandle {
6263 type View = WsView;
6264 fn node_id(&self) -> CstNodeId {
6265 self.0
6266 }
6267 fn new_with_visit<F: CstFacade, E>(
6268 index: CstNodeId,
6269 tree: &F,
6270 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6271 ) -> Result<Self, CstConstructError<E>> {
6272 tree.collect_nodes(
6273 index,
6274 [NodeKind::NonTerminal(NonTerminalKind::Ws)],
6275 |[index], visit| Ok((Self(index), visit)),
6276 visit_ignored,
6277 )
6278 }
6279 fn kind(&self) -> NonTerminalKind {
6280 NonTerminalKind::Ws
6281 }
6282 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6283 &self,
6284 tree: &F,
6285 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6286 visit_ignored: &'v mut V,
6287 ) -> Result<O, CstConstructError<E>> {
6288 tree.collect_nodes(
6289 self.0,
6290 [NodeKind::Terminal(TerminalKind::Ws)],
6291 |[ws], visit_ignored| Ok(visit(WsView { ws: Ws(ws) }, visit_ignored)),
6292 visit_ignored,
6293 )
6294 }
6295}
6296#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6297pub struct WsView {
6298 pub ws: Ws,
6299}
6300impl WsView {}
6301#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6302pub struct RootHandle(pub(crate) super::tree::CstNodeId);
6303impl NonTerminalHandle for RootHandle {
6304 type View = RootView;
6305 fn node_id(&self) -> CstNodeId {
6306 self.0
6307 }
6308 fn new_with_visit<F: CstFacade, E>(
6309 index: CstNodeId,
6310 tree: &F,
6311 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6312 ) -> Result<Self, CstConstructError<E>> {
6313 tree.collect_nodes(
6314 index,
6315 [NodeKind::NonTerminal(NonTerminalKind::Root)],
6316 |[index], visit| Ok((Self(index), visit)),
6317 visit_ignored,
6318 )
6319 }
6320 fn kind(&self) -> NonTerminalKind {
6321 NonTerminalKind::Root
6322 }
6323 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6324 &self,
6325 tree: &F,
6326 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6327 visit_ignored: &'v mut V,
6328 ) -> Result<O, CstConstructError<E>> {
6329 tree.collect_nodes(
6330 self.0,
6331 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
6332 |[eure], visit_ignored| {
6333 Ok(visit(
6334 RootView {
6335 eure: EureHandle(eure),
6336 },
6337 visit_ignored,
6338 ))
6339 },
6340 visit_ignored,
6341 )
6342 }
6343}
6344#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6345pub struct RootView {
6346 pub eure: EureHandle,
6347}
6348impl RootView {}
6349#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6350pub struct NewLine(pub(crate) super::tree::CstNodeId);
6351impl TerminalHandle for NewLine {
6352 fn node_id(&self) -> CstNodeId {
6353 self.0
6354 }
6355 fn kind(&self) -> TerminalKind {
6356 TerminalKind::NewLine
6357 }
6358}
6359#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6360pub struct Whitespace(pub(crate) super::tree::CstNodeId);
6361impl TerminalHandle for Whitespace {
6362 fn node_id(&self) -> CstNodeId {
6363 self.0
6364 }
6365 fn kind(&self) -> TerminalKind {
6366 TerminalKind::Whitespace
6367 }
6368}
6369#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6370pub struct LineComment(pub(crate) super::tree::CstNodeId);
6371impl TerminalHandle for LineComment {
6372 fn node_id(&self) -> CstNodeId {
6373 self.0
6374 }
6375 fn kind(&self) -> TerminalKind {
6376 TerminalKind::LineComment
6377 }
6378}
6379#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6380pub struct BlockComment(pub(crate) super::tree::CstNodeId);
6381impl TerminalHandle for BlockComment {
6382 fn node_id(&self) -> CstNodeId {
6383 self.0
6384 }
6385 fn kind(&self) -> TerminalKind {
6386 TerminalKind::BlockComment
6387 }
6388}
6389#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6390pub struct Hash(pub(crate) super::tree::CstNodeId);
6391impl TerminalHandle for Hash {
6392 fn node_id(&self) -> CstNodeId {
6393 self.0
6394 }
6395 fn kind(&self) -> TerminalKind {
6396 TerminalKind::Hash
6397 }
6398}
6399#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6400pub struct MapBind(pub(crate) super::tree::CstNodeId);
6401impl TerminalHandle for MapBind {
6402 fn node_id(&self) -> CstNodeId {
6403 self.0
6404 }
6405 fn kind(&self) -> TerminalKind {
6406 TerminalKind::MapBind
6407 }
6408}
6409#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6410pub struct Integer(pub(crate) super::tree::CstNodeId);
6411impl TerminalHandle for Integer {
6412 fn node_id(&self) -> CstNodeId {
6413 self.0
6414 }
6415 fn kind(&self) -> TerminalKind {
6416 TerminalKind::Integer
6417 }
6418}
6419#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6420pub struct Float(pub(crate) super::tree::CstNodeId);
6421impl TerminalHandle for Float {
6422 fn node_id(&self) -> CstNodeId {
6423 self.0
6424 }
6425 fn kind(&self) -> TerminalKind {
6426 TerminalKind::Float
6427 }
6428}
6429#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6430pub struct Inf(pub(crate) super::tree::CstNodeId);
6431impl TerminalHandle for Inf {
6432 fn node_id(&self) -> CstNodeId {
6433 self.0
6434 }
6435 fn kind(&self) -> TerminalKind {
6436 TerminalKind::Inf
6437 }
6438}
6439#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6440pub struct NaN(pub(crate) super::tree::CstNodeId);
6441impl TerminalHandle for NaN {
6442 fn node_id(&self) -> CstNodeId {
6443 self.0
6444 }
6445 fn kind(&self) -> TerminalKind {
6446 TerminalKind::NaN
6447 }
6448}
6449#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6450pub struct True(pub(crate) super::tree::CstNodeId);
6451impl TerminalHandle for True {
6452 fn node_id(&self) -> CstNodeId {
6453 self.0
6454 }
6455 fn kind(&self) -> TerminalKind {
6456 TerminalKind::True
6457 }
6458}
6459#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6460pub struct False(pub(crate) super::tree::CstNodeId);
6461impl TerminalHandle for False {
6462 fn node_id(&self) -> CstNodeId {
6463 self.0
6464 }
6465 fn kind(&self) -> TerminalKind {
6466 TerminalKind::False
6467 }
6468}
6469#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6470pub struct Null(pub(crate) super::tree::CstNodeId);
6471impl TerminalHandle for Null {
6472 fn node_id(&self) -> CstNodeId {
6473 self.0
6474 }
6475 fn kind(&self) -> TerminalKind {
6476 TerminalKind::Null
6477 }
6478}
6479#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6480pub struct Hole(pub(crate) super::tree::CstNodeId);
6481impl TerminalHandle for Hole {
6482 fn node_id(&self) -> CstNodeId {
6483 self.0
6484 }
6485 fn kind(&self) -> TerminalKind {
6486 TerminalKind::Hole
6487 }
6488}
6489#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6490pub struct Str(pub(crate) super::tree::CstNodeId);
6491impl TerminalHandle for Str {
6492 fn node_id(&self) -> CstNodeId {
6493 self.0
6494 }
6495 fn kind(&self) -> TerminalKind {
6496 TerminalKind::Str
6497 }
6498}
6499#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6500pub struct Text(pub(crate) super::tree::CstNodeId);
6501impl TerminalHandle for Text {
6502 fn node_id(&self) -> CstNodeId {
6503 self.0
6504 }
6505 fn kind(&self) -> TerminalKind {
6506 TerminalKind::Text
6507 }
6508}
6509#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6510pub struct InlineCode1(pub(crate) super::tree::CstNodeId);
6511impl TerminalHandle for InlineCode1 {
6512 fn node_id(&self) -> CstNodeId {
6513 self.0
6514 }
6515 fn kind(&self) -> TerminalKind {
6516 TerminalKind::InlineCode1
6517 }
6518}
6519#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6520pub struct InlineCodeStart2(pub(crate) super::tree::CstNodeId);
6521impl TerminalHandle for InlineCodeStart2 {
6522 fn node_id(&self) -> CstNodeId {
6523 self.0
6524 }
6525 fn kind(&self) -> TerminalKind {
6526 TerminalKind::InlineCodeStart2
6527 }
6528}
6529#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6530pub struct CodeBlockStart3(pub(crate) super::tree::CstNodeId);
6531impl TerminalHandle for CodeBlockStart3 {
6532 fn node_id(&self) -> CstNodeId {
6533 self.0
6534 }
6535 fn kind(&self) -> TerminalKind {
6536 TerminalKind::CodeBlockStart3
6537 }
6538}
6539#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6540pub struct CodeBlockStart4(pub(crate) super::tree::CstNodeId);
6541impl TerminalHandle for CodeBlockStart4 {
6542 fn node_id(&self) -> CstNodeId {
6543 self.0
6544 }
6545 fn kind(&self) -> TerminalKind {
6546 TerminalKind::CodeBlockStart4
6547 }
6548}
6549#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6550pub struct CodeBlockStart5(pub(crate) super::tree::CstNodeId);
6551impl TerminalHandle for CodeBlockStart5 {
6552 fn node_id(&self) -> CstNodeId {
6553 self.0
6554 }
6555 fn kind(&self) -> TerminalKind {
6556 TerminalKind::CodeBlockStart5
6557 }
6558}
6559#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6560pub struct CodeBlockStart6(pub(crate) super::tree::CstNodeId);
6561impl TerminalHandle for CodeBlockStart6 {
6562 fn node_id(&self) -> CstNodeId {
6563 self.0
6564 }
6565 fn kind(&self) -> TerminalKind {
6566 TerminalKind::CodeBlockStart6
6567 }
6568}
6569#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6570pub struct CodeBlockEnd3(pub(crate) super::tree::CstNodeId);
6571impl TerminalHandle for CodeBlockEnd3 {
6572 fn node_id(&self) -> CstNodeId {
6573 self.0
6574 }
6575 fn kind(&self) -> TerminalKind {
6576 TerminalKind::CodeBlockEnd3
6577 }
6578}
6579#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6580pub struct Backtick2(pub(crate) super::tree::CstNodeId);
6581impl TerminalHandle for Backtick2 {
6582 fn node_id(&self) -> CstNodeId {
6583 self.0
6584 }
6585 fn kind(&self) -> TerminalKind {
6586 TerminalKind::Backtick2
6587 }
6588}
6589#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6590pub struct CodeBlockEnd4(pub(crate) super::tree::CstNodeId);
6591impl TerminalHandle for CodeBlockEnd4 {
6592 fn node_id(&self) -> CstNodeId {
6593 self.0
6594 }
6595 fn kind(&self) -> TerminalKind {
6596 TerminalKind::CodeBlockEnd4
6597 }
6598}
6599#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6600pub struct Backtick3(pub(crate) super::tree::CstNodeId);
6601impl TerminalHandle for Backtick3 {
6602 fn node_id(&self) -> CstNodeId {
6603 self.0
6604 }
6605 fn kind(&self) -> TerminalKind {
6606 TerminalKind::Backtick3
6607 }
6608}
6609#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6610pub struct CodeBlockEnd5(pub(crate) super::tree::CstNodeId);
6611impl TerminalHandle for CodeBlockEnd5 {
6612 fn node_id(&self) -> CstNodeId {
6613 self.0
6614 }
6615 fn kind(&self) -> TerminalKind {
6616 TerminalKind::CodeBlockEnd5
6617 }
6618}
6619#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6620pub struct Backtick4(pub(crate) super::tree::CstNodeId);
6621impl TerminalHandle for Backtick4 {
6622 fn node_id(&self) -> CstNodeId {
6623 self.0
6624 }
6625 fn kind(&self) -> TerminalKind {
6626 TerminalKind::Backtick4
6627 }
6628}
6629#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6630pub struct CodeBlockEnd6(pub(crate) super::tree::CstNodeId);
6631impl TerminalHandle for CodeBlockEnd6 {
6632 fn node_id(&self) -> CstNodeId {
6633 self.0
6634 }
6635 fn kind(&self) -> TerminalKind {
6636 TerminalKind::CodeBlockEnd6
6637 }
6638}
6639#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6640pub struct Backtick5(pub(crate) super::tree::CstNodeId);
6641impl TerminalHandle for Backtick5 {
6642 fn node_id(&self) -> CstNodeId {
6643 self.0
6644 }
6645 fn kind(&self) -> TerminalKind {
6646 TerminalKind::Backtick5
6647 }
6648}
6649#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6650pub struct InlineCodeEnd2(pub(crate) super::tree::CstNodeId);
6651impl TerminalHandle for InlineCodeEnd2 {
6652 fn node_id(&self) -> CstNodeId {
6653 self.0
6654 }
6655 fn kind(&self) -> TerminalKind {
6656 TerminalKind::InlineCodeEnd2
6657 }
6658}
6659#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6660pub struct Backtick1(pub(crate) super::tree::CstNodeId);
6661impl TerminalHandle for Backtick1 {
6662 fn node_id(&self) -> CstNodeId {
6663 self.0
6664 }
6665 fn kind(&self) -> TerminalKind {
6666 TerminalKind::Backtick1
6667 }
6668}
6669#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6670pub struct NoBacktick(pub(crate) super::tree::CstNodeId);
6671impl TerminalHandle for NoBacktick {
6672 fn node_id(&self) -> CstNodeId {
6673 self.0
6674 }
6675 fn kind(&self) -> TerminalKind {
6676 TerminalKind::NoBacktick
6677 }
6678}
6679#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6680pub struct NoBacktickInline(pub(crate) super::tree::CstNodeId);
6681impl TerminalHandle for NoBacktickInline {
6682 fn node_id(&self) -> CstNodeId {
6683 self.0
6684 }
6685 fn kind(&self) -> TerminalKind {
6686 TerminalKind::NoBacktickInline
6687 }
6688}
6689#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6690pub struct GrammarNewline(pub(crate) super::tree::CstNodeId);
6691impl TerminalHandle for GrammarNewline {
6692 fn node_id(&self) -> CstNodeId {
6693 self.0
6694 }
6695 fn kind(&self) -> TerminalKind {
6696 TerminalKind::GrammarNewline
6697 }
6698}
6699#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6700pub struct Ws(pub(crate) super::tree::CstNodeId);
6701impl TerminalHandle for Ws {
6702 fn node_id(&self) -> CstNodeId {
6703 self.0
6704 }
6705 fn kind(&self) -> TerminalKind {
6706 TerminalKind::Ws
6707 }
6708}
6709#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6710pub struct At(pub(crate) super::tree::CstNodeId);
6711impl TerminalHandle for At {
6712 fn node_id(&self) -> CstNodeId {
6713 self.0
6714 }
6715 fn kind(&self) -> TerminalKind {
6716 TerminalKind::At
6717 }
6718}
6719#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6720pub struct Dollar(pub(crate) super::tree::CstNodeId);
6721impl TerminalHandle for Dollar {
6722 fn node_id(&self) -> CstNodeId {
6723 self.0
6724 }
6725 fn kind(&self) -> TerminalKind {
6726 TerminalKind::Dollar
6727 }
6728}
6729#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6730pub struct Dot(pub(crate) super::tree::CstNodeId);
6731impl TerminalHandle for Dot {
6732 fn node_id(&self) -> CstNodeId {
6733 self.0
6734 }
6735 fn kind(&self) -> TerminalKind {
6736 TerminalKind::Dot
6737 }
6738}
6739#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6740pub struct LBrace(pub(crate) super::tree::CstNodeId);
6741impl TerminalHandle for LBrace {
6742 fn node_id(&self) -> CstNodeId {
6743 self.0
6744 }
6745 fn kind(&self) -> TerminalKind {
6746 TerminalKind::LBrace
6747 }
6748}
6749#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6750pub struct RBrace(pub(crate) super::tree::CstNodeId);
6751impl TerminalHandle for RBrace {
6752 fn node_id(&self) -> CstNodeId {
6753 self.0
6754 }
6755 fn kind(&self) -> TerminalKind {
6756 TerminalKind::RBrace
6757 }
6758}
6759#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6760pub struct LBracket(pub(crate) super::tree::CstNodeId);
6761impl TerminalHandle for LBracket {
6762 fn node_id(&self) -> CstNodeId {
6763 self.0
6764 }
6765 fn kind(&self) -> TerminalKind {
6766 TerminalKind::LBracket
6767 }
6768}
6769#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6770pub struct RBracket(pub(crate) super::tree::CstNodeId);
6771impl TerminalHandle for RBracket {
6772 fn node_id(&self) -> CstNodeId {
6773 self.0
6774 }
6775 fn kind(&self) -> TerminalKind {
6776 TerminalKind::RBracket
6777 }
6778}
6779#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6780pub struct LParen(pub(crate) super::tree::CstNodeId);
6781impl TerminalHandle for LParen {
6782 fn node_id(&self) -> CstNodeId {
6783 self.0
6784 }
6785 fn kind(&self) -> TerminalKind {
6786 TerminalKind::LParen
6787 }
6788}
6789#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6790pub struct RParen(pub(crate) super::tree::CstNodeId);
6791impl TerminalHandle for RParen {
6792 fn node_id(&self) -> CstNodeId {
6793 self.0
6794 }
6795 fn kind(&self) -> TerminalKind {
6796 TerminalKind::RParen
6797 }
6798}
6799#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6800pub struct Bind(pub(crate) super::tree::CstNodeId);
6801impl TerminalHandle for Bind {
6802 fn node_id(&self) -> CstNodeId {
6803 self.0
6804 }
6805 fn kind(&self) -> TerminalKind {
6806 TerminalKind::Bind
6807 }
6808}
6809#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6810pub struct Comma(pub(crate) super::tree::CstNodeId);
6811impl TerminalHandle for Comma {
6812 fn node_id(&self) -> CstNodeId {
6813 self.0
6814 }
6815 fn kind(&self) -> TerminalKind {
6816 TerminalKind::Comma
6817 }
6818}
6819#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6820pub struct Esc(pub(crate) super::tree::CstNodeId);
6821impl TerminalHandle for Esc {
6822 fn node_id(&self) -> CstNodeId {
6823 self.0
6824 }
6825 fn kind(&self) -> TerminalKind {
6826 TerminalKind::Esc
6827 }
6828}
6829#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6830pub struct TextStart(pub(crate) super::tree::CstNodeId);
6831impl TerminalHandle for TextStart {
6832 fn node_id(&self) -> CstNodeId {
6833 self.0
6834 }
6835 fn kind(&self) -> TerminalKind {
6836 TerminalKind::TextStart
6837 }
6838}
6839#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
6840pub struct Ident(pub(crate) super::tree::CstNodeId);
6841impl TerminalHandle for Ident {
6842 fn node_id(&self) -> CstNodeId {
6843 self.0
6844 }
6845 fn kind(&self) -> TerminalKind {
6846 TerminalKind::Ident
6847 }
6848}