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 Backtick2Handle(pub(crate) super::tree::CstNodeId);
533impl NonTerminalHandle for Backtick2Handle {
534 type View = Backtick2View;
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::Backtick2)],
546 |[index], visit| Ok((Self(index), visit)),
547 visit_ignored,
548 )
549 }
550 fn kind(&self) -> NonTerminalKind {
551 NonTerminalKind::Backtick2
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::Backtick2)],
562 |[backtick_2], visit_ignored| {
563 Ok(visit(
564 Backtick2View {
565 backtick_2: Backtick2(backtick_2),
566 },
567 visit_ignored,
568 ))
569 },
570 visit_ignored,
571 )
572 }
573}
574#[derive(Debug, Clone, Copy, PartialEq, Eq)]
575pub struct Backtick2View {
576 pub backtick_2: Backtick2,
577}
578impl Backtick2View {}
579#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
580pub struct Backtick3Handle(pub(crate) super::tree::CstNodeId);
581impl NonTerminalHandle for Backtick3Handle {
582 type View = Backtick3View;
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::Backtick3)],
594 |[index], visit| Ok((Self(index), visit)),
595 visit_ignored,
596 )
597 }
598 fn kind(&self) -> NonTerminalKind {
599 NonTerminalKind::Backtick3
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::Backtick3)],
610 |[backtick_3], visit_ignored| {
611 Ok(visit(
612 Backtick3View {
613 backtick_3: Backtick3(backtick_3),
614 },
615 visit_ignored,
616 ))
617 },
618 visit_ignored,
619 )
620 }
621}
622#[derive(Debug, Clone, Copy, PartialEq, Eq)]
623pub struct Backtick3View {
624 pub backtick_3: Backtick3,
625}
626impl Backtick3View {}
627#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
628pub struct Backtick4Handle(pub(crate) super::tree::CstNodeId);
629impl NonTerminalHandle for Backtick4Handle {
630 type View = Backtick4View;
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::Backtick4)],
642 |[index], visit| Ok((Self(index), visit)),
643 visit_ignored,
644 )
645 }
646 fn kind(&self) -> NonTerminalKind {
647 NonTerminalKind::Backtick4
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::Backtick4)],
658 |[backtick_4], visit_ignored| {
659 Ok(visit(
660 Backtick4View {
661 backtick_4: Backtick4(backtick_4),
662 },
663 visit_ignored,
664 ))
665 },
666 visit_ignored,
667 )
668 }
669}
670#[derive(Debug, Clone, Copy, PartialEq, Eq)]
671pub struct Backtick4View {
672 pub backtick_4: Backtick4,
673}
674impl Backtick4View {}
675#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
676pub struct Backtick5Handle(pub(crate) super::tree::CstNodeId);
677impl NonTerminalHandle for Backtick5Handle {
678 type View = Backtick5View;
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::Backtick5)],
690 |[index], visit| Ok((Self(index), visit)),
691 visit_ignored,
692 )
693 }
694 fn kind(&self) -> NonTerminalKind {
695 NonTerminalKind::Backtick5
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::Backtick5)],
706 |[backtick_5], visit_ignored| {
707 Ok(visit(
708 Backtick5View {
709 backtick_5: Backtick5(backtick_5),
710 },
711 visit_ignored,
712 ))
713 },
714 visit_ignored,
715 )
716 }
717}
718#[derive(Debug, Clone, Copy, PartialEq, Eq)]
719pub struct Backtick5View {
720 pub backtick_5: Backtick5,
721}
722impl Backtick5View {}
723#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
724pub struct BacktickDelimHandle(pub(crate) super::tree::CstNodeId);
725impl NonTerminalHandle for BacktickDelimHandle {
726 type View = BacktickDelimView;
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::BacktickDelim)],
738 |[index], visit| Ok((Self(index), visit)),
739 visit_ignored,
740 )
741 }
742 fn kind(&self) -> NonTerminalKind {
743 NonTerminalKind::BacktickDelim
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::BacktickDelim)],
754 |[backtick_delim], visit_ignored| {
755 Ok(visit(
756 BacktickDelimView {
757 backtick_delim: BacktickDelim(backtick_delim),
758 },
759 visit_ignored,
760 ))
761 },
762 visit_ignored,
763 )
764 }
765}
766#[derive(Debug, Clone, Copy, PartialEq, Eq)]
767pub struct BacktickDelimView {
768 pub backtick_delim: BacktickDelim,
769}
770impl BacktickDelimView {}
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 DelimCodeHandle(pub(crate) super::tree::CstNodeId);
2389impl NonTerminalHandle for DelimCodeHandle {
2390 type View = DelimCodeView;
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::DelimCode)],
2402 |[index], visit| Ok((Self(index), visit)),
2403 visit_ignored,
2404 )
2405 }
2406 fn kind(&self) -> NonTerminalKind {
2407 NonTerminalKind::DelimCode
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 let mut children = tree.children(self.0);
2416 let Some(child) = children.next() else {
2417 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
2418 };
2419 let Some(child_data) = tree.node_data(child) else {
2420 return Err(ViewConstructionError::NodeIdNotFound { node: child });
2421 };
2422 let variant = match child_data.node_kind() {
2423 NodeKind::NonTerminal(NonTerminalKind::DelimCode3) => {
2424 DelimCodeView::DelimCode3(DelimCode3Handle(child))
2425 }
2426 NodeKind::NonTerminal(NonTerminalKind::DelimCode2) => {
2427 DelimCodeView::DelimCode2(DelimCode2Handle(child))
2428 }
2429 NodeKind::NonTerminal(NonTerminalKind::DelimCode1) => {
2430 DelimCodeView::DelimCode1(DelimCode1Handle(child))
2431 }
2432 _ => {
2433 return Err(ViewConstructionError::UnexpectedNode {
2434 node: child,
2435 data: child_data,
2436 expected_kind: child_data.node_kind(),
2437 });
2438 }
2439 };
2440 let (result, _visit) = visit(variant, visit_ignored);
2441 if let Some(extra_child) = children.next() {
2442 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
2443 }
2444 Ok(result)
2445 }
2446}
2447#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2448pub enum DelimCodeView {
2449 DelimCode3(DelimCode3Handle),
2450 DelimCode2(DelimCode2Handle),
2451 DelimCode1(DelimCode1Handle),
2452}
2453impl DelimCodeView {}
2454#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2455pub struct DelimCode1Handle(pub(crate) super::tree::CstNodeId);
2456impl NonTerminalHandle for DelimCode1Handle {
2457 type View = DelimCode1View;
2458 fn node_id(&self) -> CstNodeId {
2459 self.0
2460 }
2461 fn new_with_visit<F: CstFacade, E>(
2462 index: CstNodeId,
2463 tree: &F,
2464 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2465 ) -> Result<Self, CstConstructError<E>> {
2466 tree.collect_nodes(
2467 index,
2468 [NodeKind::NonTerminal(NonTerminalKind::DelimCode1)],
2469 |[index], visit| Ok((Self(index), visit)),
2470 visit_ignored,
2471 )
2472 }
2473 fn kind(&self) -> NonTerminalKind {
2474 NonTerminalKind::DelimCode1
2475 }
2476 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2477 &self,
2478 tree: &F,
2479 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2480 visit_ignored: &'v mut V,
2481 ) -> Result<O, CstConstructError<E>> {
2482 tree.collect_nodes(
2483 self.0,
2484 [
2485 NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart1),
2486 NodeKind::NonTerminal(NonTerminalKind::DelimCode1List),
2487 NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd1),
2488 ],
2489 |[delim_code_start_1, delim_code_1_list, delim_code_end_1], visit_ignored| {
2490 Ok(visit(
2491 DelimCode1View {
2492 delim_code_start_1: DelimCodeStart1Handle(delim_code_start_1),
2493 delim_code_1_list: DelimCode1ListHandle(delim_code_1_list),
2494 delim_code_end_1: DelimCodeEnd1Handle(delim_code_end_1),
2495 },
2496 visit_ignored,
2497 ))
2498 },
2499 visit_ignored,
2500 )
2501 }
2502}
2503#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2504pub struct DelimCode1View {
2505 pub delim_code_start_1: DelimCodeStart1Handle,
2506 pub delim_code_1_list: DelimCode1ListHandle,
2507 pub delim_code_end_1: DelimCodeEnd1Handle,
2508}
2509impl DelimCode1View {}
2510#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2511pub struct DelimCode1ListHandle(pub(crate) super::tree::CstNodeId);
2512impl NonTerminalHandle for DelimCode1ListHandle {
2513 type View = Option<DelimCode1ListView>;
2514 fn node_id(&self) -> CstNodeId {
2515 self.0
2516 }
2517 fn new_with_visit<F: CstFacade, E>(
2518 index: CstNodeId,
2519 tree: &F,
2520 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2521 ) -> Result<Self, CstConstructError<E>> {
2522 tree.collect_nodes(
2523 index,
2524 [NodeKind::NonTerminal(NonTerminalKind::DelimCode1List)],
2525 |[index], visit| Ok((Self(index), visit)),
2526 visit_ignored,
2527 )
2528 }
2529 fn kind(&self) -> NonTerminalKind {
2530 NonTerminalKind::DelimCode1List
2531 }
2532 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2533 &self,
2534 tree: &F,
2535 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2536 visit_ignored: &'v mut V,
2537 ) -> Result<O, CstConstructError<E>> {
2538 if tree.has_no_children(self.0) {
2539 return Ok(visit(None, visit_ignored).0);
2540 }
2541 tree.collect_nodes(
2542 self.0,
2543 [
2544 NodeKind::NonTerminal(NonTerminalKind::DelimCode1ListGroup),
2545 NodeKind::NonTerminal(NonTerminalKind::DelimCode1List),
2546 ],
2547 |[delim_code_1_list_group, delim_code_1_list], visit_ignored| {
2548 Ok(visit(
2549 Some(DelimCode1ListView {
2550 delim_code_1_list_group: DelimCode1ListGroupHandle(delim_code_1_list_group),
2551 delim_code_1_list: DelimCode1ListHandle(delim_code_1_list),
2552 }),
2553 visit_ignored,
2554 ))
2555 },
2556 visit_ignored,
2557 )
2558 }
2559}
2560#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2561pub struct DelimCode1ListView {
2562 pub delim_code_1_list_group: DelimCode1ListGroupHandle,
2563 pub delim_code_1_list: DelimCode1ListHandle,
2564}
2565impl<F: CstFacade> RecursiveView<F> for DelimCode1ListView {
2566 type Item = DelimCode1ListGroupHandle;
2567 fn get_all_with_visit<E>(
2568 &self,
2569 tree: &F,
2570 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2571 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2572 let mut items = Vec::new();
2573 let mut current_view = Some(*self);
2574 while let Some(item) = current_view {
2575 let Self {
2576 delim_code_1_list_group,
2577 ..
2578 } = item;
2579 items.push(delim_code_1_list_group);
2580 item.delim_code_1_list.get_view_with_visit(
2581 tree,
2582 |view, visit_ignored| {
2583 current_view = view;
2584 ((), visit_ignored)
2585 },
2586 visit_ignored,
2587 )?;
2588 }
2589 Ok(items)
2590 }
2591}
2592#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2593pub struct DelimCode1ListGroupHandle(pub(crate) super::tree::CstNodeId);
2594impl NonTerminalHandle for DelimCode1ListGroupHandle {
2595 type View = DelimCode1ListGroupView;
2596 fn node_id(&self) -> CstNodeId {
2597 self.0
2598 }
2599 fn new_with_visit<F: CstFacade, E>(
2600 index: CstNodeId,
2601 tree: &F,
2602 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2603 ) -> Result<Self, CstConstructError<E>> {
2604 tree.collect_nodes(
2605 index,
2606 [NodeKind::NonTerminal(NonTerminalKind::DelimCode1ListGroup)],
2607 |[index], visit| Ok((Self(index), visit)),
2608 visit_ignored,
2609 )
2610 }
2611 fn kind(&self) -> NonTerminalKind {
2612 NonTerminalKind::DelimCode1ListGroup
2613 }
2614 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2615 &self,
2616 tree: &F,
2617 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2618 visit_ignored: &'v mut V,
2619 ) -> Result<O, CstConstructError<E>> {
2620 let mut children = tree.children(self.0);
2621 let Some(child) = children.next() else {
2622 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
2623 };
2624 let Some(child_data) = tree.node_data(child) else {
2625 return Err(ViewConstructionError::NodeIdNotFound { node: child });
2626 };
2627 let variant = match child_data.node_kind() {
2628 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
2629 DelimCode1ListGroupView::NoBacktick(NoBacktickHandle(child))
2630 }
2631 NodeKind::NonTerminal(NonTerminalKind::BacktickDelim) => {
2632 DelimCode1ListGroupView::BacktickDelim(BacktickDelimHandle(child))
2633 }
2634 _ => {
2635 return Err(ViewConstructionError::UnexpectedNode {
2636 node: child,
2637 data: child_data,
2638 expected_kind: child_data.node_kind(),
2639 });
2640 }
2641 };
2642 let (result, _visit) = visit(variant, visit_ignored);
2643 if let Some(extra_child) = children.next() {
2644 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
2645 }
2646 Ok(result)
2647 }
2648}
2649#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2650pub enum DelimCode1ListGroupView {
2651 NoBacktick(NoBacktickHandle),
2652 BacktickDelim(BacktickDelimHandle),
2653}
2654impl DelimCode1ListGroupView {}
2655#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2656pub struct DelimCode2Handle(pub(crate) super::tree::CstNodeId);
2657impl NonTerminalHandle for DelimCode2Handle {
2658 type View = DelimCode2View;
2659 fn node_id(&self) -> CstNodeId {
2660 self.0
2661 }
2662 fn new_with_visit<F: CstFacade, E>(
2663 index: CstNodeId,
2664 tree: &F,
2665 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2666 ) -> Result<Self, CstConstructError<E>> {
2667 tree.collect_nodes(
2668 index,
2669 [NodeKind::NonTerminal(NonTerminalKind::DelimCode2)],
2670 |[index], visit| Ok((Self(index), visit)),
2671 visit_ignored,
2672 )
2673 }
2674 fn kind(&self) -> NonTerminalKind {
2675 NonTerminalKind::DelimCode2
2676 }
2677 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2678 &self,
2679 tree: &F,
2680 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2681 visit_ignored: &'v mut V,
2682 ) -> Result<O, CstConstructError<E>> {
2683 tree.collect_nodes(
2684 self.0,
2685 [
2686 NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart2),
2687 NodeKind::NonTerminal(NonTerminalKind::DelimCode2List),
2688 NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd2),
2689 ],
2690 |[delim_code_start_2, delim_code_2_list, delim_code_end_2], visit_ignored| {
2691 Ok(visit(
2692 DelimCode2View {
2693 delim_code_start_2: DelimCodeStart2Handle(delim_code_start_2),
2694 delim_code_2_list: DelimCode2ListHandle(delim_code_2_list),
2695 delim_code_end_2: DelimCodeEnd2Handle(delim_code_end_2),
2696 },
2697 visit_ignored,
2698 ))
2699 },
2700 visit_ignored,
2701 )
2702 }
2703}
2704#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2705pub struct DelimCode2View {
2706 pub delim_code_start_2: DelimCodeStart2Handle,
2707 pub delim_code_2_list: DelimCode2ListHandle,
2708 pub delim_code_end_2: DelimCodeEnd2Handle,
2709}
2710impl DelimCode2View {}
2711#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2712pub struct DelimCode2ListHandle(pub(crate) super::tree::CstNodeId);
2713impl NonTerminalHandle for DelimCode2ListHandle {
2714 type View = Option<DelimCode2ListView>;
2715 fn node_id(&self) -> CstNodeId {
2716 self.0
2717 }
2718 fn new_with_visit<F: CstFacade, E>(
2719 index: CstNodeId,
2720 tree: &F,
2721 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2722 ) -> Result<Self, CstConstructError<E>> {
2723 tree.collect_nodes(
2724 index,
2725 [NodeKind::NonTerminal(NonTerminalKind::DelimCode2List)],
2726 |[index], visit| Ok((Self(index), visit)),
2727 visit_ignored,
2728 )
2729 }
2730 fn kind(&self) -> NonTerminalKind {
2731 NonTerminalKind::DelimCode2List
2732 }
2733 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2734 &self,
2735 tree: &F,
2736 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2737 visit_ignored: &'v mut V,
2738 ) -> Result<O, CstConstructError<E>> {
2739 if tree.has_no_children(self.0) {
2740 return Ok(visit(None, visit_ignored).0);
2741 }
2742 tree.collect_nodes(
2743 self.0,
2744 [
2745 NodeKind::NonTerminal(NonTerminalKind::DelimCode2ListGroup),
2746 NodeKind::NonTerminal(NonTerminalKind::DelimCode2List),
2747 ],
2748 |[delim_code_2_list_group, delim_code_2_list], visit_ignored| {
2749 Ok(visit(
2750 Some(DelimCode2ListView {
2751 delim_code_2_list_group: DelimCode2ListGroupHandle(delim_code_2_list_group),
2752 delim_code_2_list: DelimCode2ListHandle(delim_code_2_list),
2753 }),
2754 visit_ignored,
2755 ))
2756 },
2757 visit_ignored,
2758 )
2759 }
2760}
2761#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2762pub struct DelimCode2ListView {
2763 pub delim_code_2_list_group: DelimCode2ListGroupHandle,
2764 pub delim_code_2_list: DelimCode2ListHandle,
2765}
2766impl<F: CstFacade> RecursiveView<F> for DelimCode2ListView {
2767 type Item = DelimCode2ListGroupHandle;
2768 fn get_all_with_visit<E>(
2769 &self,
2770 tree: &F,
2771 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2772 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2773 let mut items = Vec::new();
2774 let mut current_view = Some(*self);
2775 while let Some(item) = current_view {
2776 let Self {
2777 delim_code_2_list_group,
2778 ..
2779 } = item;
2780 items.push(delim_code_2_list_group);
2781 item.delim_code_2_list.get_view_with_visit(
2782 tree,
2783 |view, visit_ignored| {
2784 current_view = view;
2785 ((), visit_ignored)
2786 },
2787 visit_ignored,
2788 )?;
2789 }
2790 Ok(items)
2791 }
2792}
2793#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2794pub struct DelimCode2ListGroupHandle(pub(crate) super::tree::CstNodeId);
2795impl NonTerminalHandle for DelimCode2ListGroupHandle {
2796 type View = DelimCode2ListGroupView;
2797 fn node_id(&self) -> CstNodeId {
2798 self.0
2799 }
2800 fn new_with_visit<F: CstFacade, E>(
2801 index: CstNodeId,
2802 tree: &F,
2803 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2804 ) -> Result<Self, CstConstructError<E>> {
2805 tree.collect_nodes(
2806 index,
2807 [NodeKind::NonTerminal(NonTerminalKind::DelimCode2ListGroup)],
2808 |[index], visit| Ok((Self(index), visit)),
2809 visit_ignored,
2810 )
2811 }
2812 fn kind(&self) -> NonTerminalKind {
2813 NonTerminalKind::DelimCode2ListGroup
2814 }
2815 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2816 &self,
2817 tree: &F,
2818 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2819 visit_ignored: &'v mut V,
2820 ) -> Result<O, CstConstructError<E>> {
2821 let mut children = tree.children(self.0);
2822 let Some(child) = children.next() else {
2823 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
2824 };
2825 let Some(child_data) = tree.node_data(child) else {
2826 return Err(ViewConstructionError::NodeIdNotFound { node: child });
2827 };
2828 let variant = match child_data.node_kind() {
2829 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
2830 DelimCode2ListGroupView::NoBacktick(NoBacktickHandle(child))
2831 }
2832 NodeKind::NonTerminal(NonTerminalKind::BacktickDelim) => {
2833 DelimCode2ListGroupView::BacktickDelim(BacktickDelimHandle(child))
2834 }
2835 _ => {
2836 return Err(ViewConstructionError::UnexpectedNode {
2837 node: child,
2838 data: child_data,
2839 expected_kind: child_data.node_kind(),
2840 });
2841 }
2842 };
2843 let (result, _visit) = visit(variant, visit_ignored);
2844 if let Some(extra_child) = children.next() {
2845 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
2846 }
2847 Ok(result)
2848 }
2849}
2850#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2851pub enum DelimCode2ListGroupView {
2852 NoBacktick(NoBacktickHandle),
2853 BacktickDelim(BacktickDelimHandle),
2854}
2855impl DelimCode2ListGroupView {}
2856#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2857pub struct DelimCode3Handle(pub(crate) super::tree::CstNodeId);
2858impl NonTerminalHandle for DelimCode3Handle {
2859 type View = DelimCode3View;
2860 fn node_id(&self) -> CstNodeId {
2861 self.0
2862 }
2863 fn new_with_visit<F: CstFacade, E>(
2864 index: CstNodeId,
2865 tree: &F,
2866 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2867 ) -> Result<Self, CstConstructError<E>> {
2868 tree.collect_nodes(
2869 index,
2870 [NodeKind::NonTerminal(NonTerminalKind::DelimCode3)],
2871 |[index], visit| Ok((Self(index), visit)),
2872 visit_ignored,
2873 )
2874 }
2875 fn kind(&self) -> NonTerminalKind {
2876 NonTerminalKind::DelimCode3
2877 }
2878 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2879 &self,
2880 tree: &F,
2881 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2882 visit_ignored: &'v mut V,
2883 ) -> Result<O, CstConstructError<E>> {
2884 tree.collect_nodes(
2885 self.0,
2886 [
2887 NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart3),
2888 NodeKind::NonTerminal(NonTerminalKind::DelimCode3List),
2889 NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd3),
2890 ],
2891 |[delim_code_start_3, delim_code_3_list, delim_code_end_3], visit_ignored| {
2892 Ok(visit(
2893 DelimCode3View {
2894 delim_code_start_3: DelimCodeStart3Handle(delim_code_start_3),
2895 delim_code_3_list: DelimCode3ListHandle(delim_code_3_list),
2896 delim_code_end_3: DelimCodeEnd3Handle(delim_code_end_3),
2897 },
2898 visit_ignored,
2899 ))
2900 },
2901 visit_ignored,
2902 )
2903 }
2904}
2905#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2906pub struct DelimCode3View {
2907 pub delim_code_start_3: DelimCodeStart3Handle,
2908 pub delim_code_3_list: DelimCode3ListHandle,
2909 pub delim_code_end_3: DelimCodeEnd3Handle,
2910}
2911impl DelimCode3View {}
2912#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2913pub struct DelimCode3ListHandle(pub(crate) super::tree::CstNodeId);
2914impl NonTerminalHandle for DelimCode3ListHandle {
2915 type View = Option<DelimCode3ListView>;
2916 fn node_id(&self) -> CstNodeId {
2917 self.0
2918 }
2919 fn new_with_visit<F: CstFacade, E>(
2920 index: CstNodeId,
2921 tree: &F,
2922 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2923 ) -> Result<Self, CstConstructError<E>> {
2924 tree.collect_nodes(
2925 index,
2926 [NodeKind::NonTerminal(NonTerminalKind::DelimCode3List)],
2927 |[index], visit| Ok((Self(index), visit)),
2928 visit_ignored,
2929 )
2930 }
2931 fn kind(&self) -> NonTerminalKind {
2932 NonTerminalKind::DelimCode3List
2933 }
2934 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2935 &self,
2936 tree: &F,
2937 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2938 visit_ignored: &'v mut V,
2939 ) -> Result<O, CstConstructError<E>> {
2940 if tree.has_no_children(self.0) {
2941 return Ok(visit(None, visit_ignored).0);
2942 }
2943 tree.collect_nodes(
2944 self.0,
2945 [
2946 NodeKind::NonTerminal(NonTerminalKind::DelimCode3ListGroup),
2947 NodeKind::NonTerminal(NonTerminalKind::DelimCode3List),
2948 ],
2949 |[delim_code_3_list_group, delim_code_3_list], visit_ignored| {
2950 Ok(visit(
2951 Some(DelimCode3ListView {
2952 delim_code_3_list_group: DelimCode3ListGroupHandle(delim_code_3_list_group),
2953 delim_code_3_list: DelimCode3ListHandle(delim_code_3_list),
2954 }),
2955 visit_ignored,
2956 ))
2957 },
2958 visit_ignored,
2959 )
2960 }
2961}
2962#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2963pub struct DelimCode3ListView {
2964 pub delim_code_3_list_group: DelimCode3ListGroupHandle,
2965 pub delim_code_3_list: DelimCode3ListHandle,
2966}
2967impl<F: CstFacade> RecursiveView<F> for DelimCode3ListView {
2968 type Item = DelimCode3ListGroupHandle;
2969 fn get_all_with_visit<E>(
2970 &self,
2971 tree: &F,
2972 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2973 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2974 let mut items = Vec::new();
2975 let mut current_view = Some(*self);
2976 while let Some(item) = current_view {
2977 let Self {
2978 delim_code_3_list_group,
2979 ..
2980 } = item;
2981 items.push(delim_code_3_list_group);
2982 item.delim_code_3_list.get_view_with_visit(
2983 tree,
2984 |view, visit_ignored| {
2985 current_view = view;
2986 ((), visit_ignored)
2987 },
2988 visit_ignored,
2989 )?;
2990 }
2991 Ok(items)
2992 }
2993}
2994#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2995pub struct DelimCode3ListGroupHandle(pub(crate) super::tree::CstNodeId);
2996impl NonTerminalHandle for DelimCode3ListGroupHandle {
2997 type View = DelimCode3ListGroupView;
2998 fn node_id(&self) -> CstNodeId {
2999 self.0
3000 }
3001 fn new_with_visit<F: CstFacade, E>(
3002 index: CstNodeId,
3003 tree: &F,
3004 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3005 ) -> Result<Self, CstConstructError<E>> {
3006 tree.collect_nodes(
3007 index,
3008 [NodeKind::NonTerminal(NonTerminalKind::DelimCode3ListGroup)],
3009 |[index], visit| Ok((Self(index), visit)),
3010 visit_ignored,
3011 )
3012 }
3013 fn kind(&self) -> NonTerminalKind {
3014 NonTerminalKind::DelimCode3ListGroup
3015 }
3016 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3017 &self,
3018 tree: &F,
3019 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3020 visit_ignored: &'v mut V,
3021 ) -> Result<O, CstConstructError<E>> {
3022 let mut children = tree.children(self.0);
3023 let Some(child) = children.next() else {
3024 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3025 };
3026 let Some(child_data) = tree.node_data(child) else {
3027 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3028 };
3029 let variant = match child_data.node_kind() {
3030 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
3031 DelimCode3ListGroupView::NoBacktick(NoBacktickHandle(child))
3032 }
3033 NodeKind::NonTerminal(NonTerminalKind::BacktickDelim) => {
3034 DelimCode3ListGroupView::BacktickDelim(BacktickDelimHandle(child))
3035 }
3036 _ => {
3037 return Err(ViewConstructionError::UnexpectedNode {
3038 node: child,
3039 data: child_data,
3040 expected_kind: child_data.node_kind(),
3041 });
3042 }
3043 };
3044 let (result, _visit) = visit(variant, visit_ignored);
3045 if let Some(extra_child) = children.next() {
3046 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3047 }
3048 Ok(result)
3049 }
3050}
3051#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3052pub enum DelimCode3ListGroupView {
3053 NoBacktick(NoBacktickHandle),
3054 BacktickDelim(BacktickDelimHandle),
3055}
3056impl DelimCode3ListGroupView {}
3057#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3058pub struct DelimCodeEnd1Handle(pub(crate) super::tree::CstNodeId);
3059impl NonTerminalHandle for DelimCodeEnd1Handle {
3060 type View = DelimCodeEnd1View;
3061 fn node_id(&self) -> CstNodeId {
3062 self.0
3063 }
3064 fn new_with_visit<F: CstFacade, E>(
3065 index: CstNodeId,
3066 tree: &F,
3067 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3068 ) -> Result<Self, CstConstructError<E>> {
3069 tree.collect_nodes(
3070 index,
3071 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd1)],
3072 |[index], visit| Ok((Self(index), visit)),
3073 visit_ignored,
3074 )
3075 }
3076 fn kind(&self) -> NonTerminalKind {
3077 NonTerminalKind::DelimCodeEnd1
3078 }
3079 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3080 &self,
3081 tree: &F,
3082 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3083 visit_ignored: &'v mut V,
3084 ) -> Result<O, CstConstructError<E>> {
3085 tree.collect_nodes(
3086 self.0,
3087 [NodeKind::Terminal(TerminalKind::DelimCodeEnd1)],
3088 |[delim_code_end_1], visit_ignored| {
3089 Ok(visit(
3090 DelimCodeEnd1View {
3091 delim_code_end_1: DelimCodeEnd1(delim_code_end_1),
3092 },
3093 visit_ignored,
3094 ))
3095 },
3096 visit_ignored,
3097 )
3098 }
3099}
3100#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3101pub struct DelimCodeEnd1View {
3102 pub delim_code_end_1: DelimCodeEnd1,
3103}
3104impl DelimCodeEnd1View {}
3105#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3106pub struct DelimCodeEnd2Handle(pub(crate) super::tree::CstNodeId);
3107impl NonTerminalHandle for DelimCodeEnd2Handle {
3108 type View = DelimCodeEnd2View;
3109 fn node_id(&self) -> CstNodeId {
3110 self.0
3111 }
3112 fn new_with_visit<F: CstFacade, E>(
3113 index: CstNodeId,
3114 tree: &F,
3115 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3116 ) -> Result<Self, CstConstructError<E>> {
3117 tree.collect_nodes(
3118 index,
3119 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd2)],
3120 |[index], visit| Ok((Self(index), visit)),
3121 visit_ignored,
3122 )
3123 }
3124 fn kind(&self) -> NonTerminalKind {
3125 NonTerminalKind::DelimCodeEnd2
3126 }
3127 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3128 &self,
3129 tree: &F,
3130 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3131 visit_ignored: &'v mut V,
3132 ) -> Result<O, CstConstructError<E>> {
3133 tree.collect_nodes(
3134 self.0,
3135 [NodeKind::Terminal(TerminalKind::DelimCodeEnd2)],
3136 |[delim_code_end_2], visit_ignored| {
3137 Ok(visit(
3138 DelimCodeEnd2View {
3139 delim_code_end_2: DelimCodeEnd2(delim_code_end_2),
3140 },
3141 visit_ignored,
3142 ))
3143 },
3144 visit_ignored,
3145 )
3146 }
3147}
3148#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3149pub struct DelimCodeEnd2View {
3150 pub delim_code_end_2: DelimCodeEnd2,
3151}
3152impl DelimCodeEnd2View {}
3153#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3154pub struct DelimCodeEnd3Handle(pub(crate) super::tree::CstNodeId);
3155impl NonTerminalHandle for DelimCodeEnd3Handle {
3156 type View = DelimCodeEnd3View;
3157 fn node_id(&self) -> CstNodeId {
3158 self.0
3159 }
3160 fn new_with_visit<F: CstFacade, E>(
3161 index: CstNodeId,
3162 tree: &F,
3163 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3164 ) -> Result<Self, CstConstructError<E>> {
3165 tree.collect_nodes(
3166 index,
3167 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd3)],
3168 |[index], visit| Ok((Self(index), visit)),
3169 visit_ignored,
3170 )
3171 }
3172 fn kind(&self) -> NonTerminalKind {
3173 NonTerminalKind::DelimCodeEnd3
3174 }
3175 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3176 &self,
3177 tree: &F,
3178 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3179 visit_ignored: &'v mut V,
3180 ) -> Result<O, CstConstructError<E>> {
3181 tree.collect_nodes(
3182 self.0,
3183 [NodeKind::Terminal(TerminalKind::DelimCodeEnd3)],
3184 |[delim_code_end_3], visit_ignored| {
3185 Ok(visit(
3186 DelimCodeEnd3View {
3187 delim_code_end_3: DelimCodeEnd3(delim_code_end_3),
3188 },
3189 visit_ignored,
3190 ))
3191 },
3192 visit_ignored,
3193 )
3194 }
3195}
3196#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3197pub struct DelimCodeEnd3View {
3198 pub delim_code_end_3: DelimCodeEnd3,
3199}
3200impl DelimCodeEnd3View {}
3201#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3202pub struct DelimCodeStart1Handle(pub(crate) super::tree::CstNodeId);
3203impl NonTerminalHandle for DelimCodeStart1Handle {
3204 type View = DelimCodeStart1View;
3205 fn node_id(&self) -> CstNodeId {
3206 self.0
3207 }
3208 fn new_with_visit<F: CstFacade, E>(
3209 index: CstNodeId,
3210 tree: &F,
3211 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3212 ) -> Result<Self, CstConstructError<E>> {
3213 tree.collect_nodes(
3214 index,
3215 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart1)],
3216 |[index], visit| Ok((Self(index), visit)),
3217 visit_ignored,
3218 )
3219 }
3220 fn kind(&self) -> NonTerminalKind {
3221 NonTerminalKind::DelimCodeStart1
3222 }
3223 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3224 &self,
3225 tree: &F,
3226 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3227 visit_ignored: &'v mut V,
3228 ) -> Result<O, CstConstructError<E>> {
3229 tree.collect_nodes(
3230 self.0,
3231 [NodeKind::Terminal(TerminalKind::DelimCodeStart1)],
3232 |[delim_code_start_1], visit_ignored| {
3233 Ok(visit(
3234 DelimCodeStart1View {
3235 delim_code_start_1: DelimCodeStart1(delim_code_start_1),
3236 },
3237 visit_ignored,
3238 ))
3239 },
3240 visit_ignored,
3241 )
3242 }
3243}
3244#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3245pub struct DelimCodeStart1View {
3246 pub delim_code_start_1: DelimCodeStart1,
3247}
3248impl DelimCodeStart1View {}
3249#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3250pub struct DelimCodeStart2Handle(pub(crate) super::tree::CstNodeId);
3251impl NonTerminalHandle for DelimCodeStart2Handle {
3252 type View = DelimCodeStart2View;
3253 fn node_id(&self) -> CstNodeId {
3254 self.0
3255 }
3256 fn new_with_visit<F: CstFacade, E>(
3257 index: CstNodeId,
3258 tree: &F,
3259 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3260 ) -> Result<Self, CstConstructError<E>> {
3261 tree.collect_nodes(
3262 index,
3263 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart2)],
3264 |[index], visit| Ok((Self(index), visit)),
3265 visit_ignored,
3266 )
3267 }
3268 fn kind(&self) -> NonTerminalKind {
3269 NonTerminalKind::DelimCodeStart2
3270 }
3271 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3272 &self,
3273 tree: &F,
3274 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3275 visit_ignored: &'v mut V,
3276 ) -> Result<O, CstConstructError<E>> {
3277 tree.collect_nodes(
3278 self.0,
3279 [NodeKind::Terminal(TerminalKind::DelimCodeStart2)],
3280 |[delim_code_start_2], visit_ignored| {
3281 Ok(visit(
3282 DelimCodeStart2View {
3283 delim_code_start_2: DelimCodeStart2(delim_code_start_2),
3284 },
3285 visit_ignored,
3286 ))
3287 },
3288 visit_ignored,
3289 )
3290 }
3291}
3292#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3293pub struct DelimCodeStart2View {
3294 pub delim_code_start_2: DelimCodeStart2,
3295}
3296impl DelimCodeStart2View {}
3297#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3298pub struct DelimCodeStart3Handle(pub(crate) super::tree::CstNodeId);
3299impl NonTerminalHandle for DelimCodeStart3Handle {
3300 type View = DelimCodeStart3View;
3301 fn node_id(&self) -> CstNodeId {
3302 self.0
3303 }
3304 fn new_with_visit<F: CstFacade, E>(
3305 index: CstNodeId,
3306 tree: &F,
3307 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3308 ) -> Result<Self, CstConstructError<E>> {
3309 tree.collect_nodes(
3310 index,
3311 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart3)],
3312 |[index], visit| Ok((Self(index), visit)),
3313 visit_ignored,
3314 )
3315 }
3316 fn kind(&self) -> NonTerminalKind {
3317 NonTerminalKind::DelimCodeStart3
3318 }
3319 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3320 &self,
3321 tree: &F,
3322 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3323 visit_ignored: &'v mut V,
3324 ) -> Result<O, CstConstructError<E>> {
3325 tree.collect_nodes(
3326 self.0,
3327 [NodeKind::Terminal(TerminalKind::DelimCodeStart3)],
3328 |[delim_code_start_3], visit_ignored| {
3329 Ok(visit(
3330 DelimCodeStart3View {
3331 delim_code_start_3: DelimCodeStart3(delim_code_start_3),
3332 },
3333 visit_ignored,
3334 ))
3335 },
3336 visit_ignored,
3337 )
3338 }
3339}
3340#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3341pub struct DelimCodeStart3View {
3342 pub delim_code_start_3: DelimCodeStart3,
3343}
3344impl DelimCodeStart3View {}
3345#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3346pub struct DotHandle(pub(crate) super::tree::CstNodeId);
3347impl NonTerminalHandle for DotHandle {
3348 type View = DotView;
3349 fn node_id(&self) -> CstNodeId {
3350 self.0
3351 }
3352 fn new_with_visit<F: CstFacade, E>(
3353 index: CstNodeId,
3354 tree: &F,
3355 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3356 ) -> Result<Self, CstConstructError<E>> {
3357 tree.collect_nodes(
3358 index,
3359 [NodeKind::NonTerminal(NonTerminalKind::Dot)],
3360 |[index], visit| Ok((Self(index), visit)),
3361 visit_ignored,
3362 )
3363 }
3364 fn kind(&self) -> NonTerminalKind {
3365 NonTerminalKind::Dot
3366 }
3367 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3368 &self,
3369 tree: &F,
3370 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3371 visit_ignored: &'v mut V,
3372 ) -> Result<O, CstConstructError<E>> {
3373 tree.collect_nodes(
3374 self.0,
3375 [NodeKind::Terminal(TerminalKind::Dot)],
3376 |[dot], visit_ignored| Ok(visit(DotView { dot: Dot(dot) }, visit_ignored)),
3377 visit_ignored,
3378 )
3379 }
3380}
3381#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3382pub struct DotView {
3383 pub dot: Dot,
3384}
3385impl DotView {}
3386#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3387pub struct EndHandle(pub(crate) super::tree::CstNodeId);
3388impl NonTerminalHandle for EndHandle {
3389 type View = EndView;
3390 fn node_id(&self) -> CstNodeId {
3391 self.0
3392 }
3393 fn new_with_visit<F: CstFacade, E>(
3394 index: CstNodeId,
3395 tree: &F,
3396 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3397 ) -> Result<Self, CstConstructError<E>> {
3398 tree.collect_nodes(
3399 index,
3400 [NodeKind::NonTerminal(NonTerminalKind::End)],
3401 |[index], visit| Ok((Self(index), visit)),
3402 visit_ignored,
3403 )
3404 }
3405 fn kind(&self) -> NonTerminalKind {
3406 NonTerminalKind::End
3407 }
3408 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3409 &self,
3410 tree: &F,
3411 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3412 visit_ignored: &'v mut V,
3413 ) -> Result<O, CstConstructError<E>> {
3414 tree.collect_nodes(
3415 self.0,
3416 [NodeKind::Terminal(TerminalKind::RBrace)],
3417 |[r_brace], visit_ignored| {
3418 Ok(visit(
3419 EndView {
3420 r_brace: RBrace(r_brace),
3421 },
3422 visit_ignored,
3423 ))
3424 },
3425 visit_ignored,
3426 )
3427 }
3428}
3429#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3430pub struct EndView {
3431 pub r_brace: RBrace,
3432}
3433impl EndView {}
3434#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3435pub struct EureHandle(pub(crate) super::tree::CstNodeId);
3436impl NonTerminalHandle for EureHandle {
3437 type View = EureView;
3438 fn node_id(&self) -> CstNodeId {
3439 self.0
3440 }
3441 fn new_with_visit<F: CstFacade, E>(
3442 index: CstNodeId,
3443 tree: &F,
3444 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3445 ) -> Result<Self, CstConstructError<E>> {
3446 tree.collect_nodes(
3447 index,
3448 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
3449 |[index], visit| Ok((Self(index), visit)),
3450 visit_ignored,
3451 )
3452 }
3453 fn kind(&self) -> NonTerminalKind {
3454 NonTerminalKind::Eure
3455 }
3456 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3457 &self,
3458 tree: &F,
3459 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3460 visit_ignored: &'v mut V,
3461 ) -> Result<O, CstConstructError<E>> {
3462 tree.collect_nodes(
3463 self.0,
3464 [
3465 NodeKind::NonTerminal(NonTerminalKind::EureOpt),
3466 NodeKind::NonTerminal(NonTerminalKind::EureList),
3467 NodeKind::NonTerminal(NonTerminalKind::EureList0),
3468 ],
3469 |[eure_opt, eure_bindings, eure_sections], visit_ignored| {
3470 Ok(visit(
3471 EureView {
3472 eure_opt: EureOptHandle(eure_opt),
3473 eure_bindings: EureBindingsHandle(eure_bindings),
3474 eure_sections: EureSectionsHandle(eure_sections),
3475 },
3476 visit_ignored,
3477 ))
3478 },
3479 visit_ignored,
3480 )
3481 }
3482}
3483#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3484pub struct EureView {
3485 pub eure_opt: EureOptHandle,
3486 pub eure_bindings: EureBindingsHandle,
3487 pub eure_sections: EureSectionsHandle,
3488}
3489impl EureView {}
3490#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3491pub struct EureBindingsHandle(pub(crate) super::tree::CstNodeId);
3492impl NonTerminalHandle for EureBindingsHandle {
3493 type View = Option<EureBindingsView>;
3494 fn node_id(&self) -> CstNodeId {
3495 self.0
3496 }
3497 fn new_with_visit<F: CstFacade, E>(
3498 index: CstNodeId,
3499 tree: &F,
3500 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3501 ) -> Result<Self, CstConstructError<E>> {
3502 tree.collect_nodes(
3503 index,
3504 [NodeKind::NonTerminal(NonTerminalKind::EureList)],
3505 |[index], visit| Ok((Self(index), visit)),
3506 visit_ignored,
3507 )
3508 }
3509 fn kind(&self) -> NonTerminalKind {
3510 NonTerminalKind::EureList
3511 }
3512 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3513 &self,
3514 tree: &F,
3515 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3516 visit_ignored: &'v mut V,
3517 ) -> Result<O, CstConstructError<E>> {
3518 if tree.has_no_children(self.0) {
3519 return Ok(visit(None, visit_ignored).0);
3520 }
3521 tree.collect_nodes(
3522 self.0,
3523 [
3524 NodeKind::NonTerminal(NonTerminalKind::Binding),
3525 NodeKind::NonTerminal(NonTerminalKind::EureList),
3526 ],
3527 |[binding, eure_bindings], visit_ignored| {
3528 Ok(visit(
3529 Some(EureBindingsView {
3530 binding: BindingHandle(binding),
3531 eure_bindings: EureBindingsHandle(eure_bindings),
3532 }),
3533 visit_ignored,
3534 ))
3535 },
3536 visit_ignored,
3537 )
3538 }
3539}
3540#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3541pub struct EureBindingsView {
3542 pub binding: BindingHandle,
3543 pub eure_bindings: EureBindingsHandle,
3544}
3545impl<F: CstFacade> RecursiveView<F> for EureBindingsView {
3546 type Item = BindingHandle;
3547 fn get_all_with_visit<E>(
3548 &self,
3549 tree: &F,
3550 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3551 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
3552 let mut items = Vec::new();
3553 let mut current_view = Some(*self);
3554 while let Some(item) = current_view {
3555 let Self { binding, .. } = item;
3556 items.push(binding);
3557 item.eure_bindings.get_view_with_visit(
3558 tree,
3559 |view, visit_ignored| {
3560 current_view = view;
3561 ((), visit_ignored)
3562 },
3563 visit_ignored,
3564 )?;
3565 }
3566 Ok(items)
3567 }
3568}
3569#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3570pub struct EureSectionsHandle(pub(crate) super::tree::CstNodeId);
3571impl NonTerminalHandle for EureSectionsHandle {
3572 type View = Option<EureSectionsView>;
3573 fn node_id(&self) -> CstNodeId {
3574 self.0
3575 }
3576 fn new_with_visit<F: CstFacade, E>(
3577 index: CstNodeId,
3578 tree: &F,
3579 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3580 ) -> Result<Self, CstConstructError<E>> {
3581 tree.collect_nodes(
3582 index,
3583 [NodeKind::NonTerminal(NonTerminalKind::EureList0)],
3584 |[index], visit| Ok((Self(index), visit)),
3585 visit_ignored,
3586 )
3587 }
3588 fn kind(&self) -> NonTerminalKind {
3589 NonTerminalKind::EureList0
3590 }
3591 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3592 &self,
3593 tree: &F,
3594 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3595 visit_ignored: &'v mut V,
3596 ) -> Result<O, CstConstructError<E>> {
3597 if tree.has_no_children(self.0) {
3598 return Ok(visit(None, visit_ignored).0);
3599 }
3600 tree.collect_nodes(
3601 self.0,
3602 [
3603 NodeKind::NonTerminal(NonTerminalKind::Section),
3604 NodeKind::NonTerminal(NonTerminalKind::EureList0),
3605 ],
3606 |[section, eure_sections], visit_ignored| {
3607 Ok(visit(
3608 Some(EureSectionsView {
3609 section: SectionHandle(section),
3610 eure_sections: EureSectionsHandle(eure_sections),
3611 }),
3612 visit_ignored,
3613 ))
3614 },
3615 visit_ignored,
3616 )
3617 }
3618}
3619#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3620pub struct EureSectionsView {
3621 pub section: SectionHandle,
3622 pub eure_sections: EureSectionsHandle,
3623}
3624impl<F: CstFacade> RecursiveView<F> for EureSectionsView {
3625 type Item = SectionHandle;
3626 fn get_all_with_visit<E>(
3627 &self,
3628 tree: &F,
3629 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3630 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
3631 let mut items = Vec::new();
3632 let mut current_view = Some(*self);
3633 while let Some(item) = current_view {
3634 let Self { section, .. } = item;
3635 items.push(section);
3636 item.eure_sections.get_view_with_visit(
3637 tree,
3638 |view, visit_ignored| {
3639 current_view = view;
3640 ((), visit_ignored)
3641 },
3642 visit_ignored,
3643 )?;
3644 }
3645 Ok(items)
3646 }
3647}
3648#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3649pub struct EureOptHandle(pub(crate) super::tree::CstNodeId);
3650impl NonTerminalHandle for EureOptHandle {
3651 type View = Option<RootBindingHandle>;
3652 fn node_id(&self) -> CstNodeId {
3653 self.0
3654 }
3655 fn new_with_visit<F: CstFacade, E>(
3656 index: CstNodeId,
3657 tree: &F,
3658 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3659 ) -> Result<Self, CstConstructError<E>> {
3660 tree.collect_nodes(
3661 index,
3662 [NodeKind::NonTerminal(NonTerminalKind::EureOpt)],
3663 |[index], visit| Ok((Self(index), visit)),
3664 visit_ignored,
3665 )
3666 }
3667 fn kind(&self) -> NonTerminalKind {
3668 NonTerminalKind::EureOpt
3669 }
3670 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3671 &self,
3672 tree: &F,
3673 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3674 visit_ignored: &'v mut V,
3675 ) -> Result<O, CstConstructError<E>> {
3676 if tree.has_no_children(self.0) {
3677 return Ok(visit(None, visit_ignored).0);
3678 }
3679 Ok(visit(
3680 Some(RootBindingHandle::new_with_visit(
3681 self.0,
3682 tree,
3683 visit_ignored,
3684 )?),
3685 visit_ignored,
3686 )
3687 .0)
3688 }
3689}
3690#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3691pub struct ExtHandle(pub(crate) super::tree::CstNodeId);
3692impl NonTerminalHandle for ExtHandle {
3693 type View = ExtView;
3694 fn node_id(&self) -> CstNodeId {
3695 self.0
3696 }
3697 fn new_with_visit<F: CstFacade, E>(
3698 index: CstNodeId,
3699 tree: &F,
3700 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3701 ) -> Result<Self, CstConstructError<E>> {
3702 tree.collect_nodes(
3703 index,
3704 [NodeKind::NonTerminal(NonTerminalKind::Ext)],
3705 |[index], visit| Ok((Self(index), visit)),
3706 visit_ignored,
3707 )
3708 }
3709 fn kind(&self) -> NonTerminalKind {
3710 NonTerminalKind::Ext
3711 }
3712 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3713 &self,
3714 tree: &F,
3715 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3716 visit_ignored: &'v mut V,
3717 ) -> Result<O, CstConstructError<E>> {
3718 tree.collect_nodes(
3719 self.0,
3720 [NodeKind::Terminal(TerminalKind::Dollar)],
3721 |[dollar], visit_ignored| {
3722 Ok(visit(
3723 ExtView {
3724 dollar: Dollar(dollar),
3725 },
3726 visit_ignored,
3727 ))
3728 },
3729 visit_ignored,
3730 )
3731 }
3732}
3733#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3734pub struct ExtView {
3735 pub dollar: Dollar,
3736}
3737impl ExtView {}
3738#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3739pub struct ExtensionNameSpaceHandle(pub(crate) super::tree::CstNodeId);
3740impl NonTerminalHandle for ExtensionNameSpaceHandle {
3741 type View = ExtensionNameSpaceView;
3742 fn node_id(&self) -> CstNodeId {
3743 self.0
3744 }
3745 fn new_with_visit<F: CstFacade, E>(
3746 index: CstNodeId,
3747 tree: &F,
3748 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3749 ) -> Result<Self, CstConstructError<E>> {
3750 tree.collect_nodes(
3751 index,
3752 [NodeKind::NonTerminal(NonTerminalKind::ExtensionNameSpace)],
3753 |[index], visit| Ok((Self(index), visit)),
3754 visit_ignored,
3755 )
3756 }
3757 fn kind(&self) -> NonTerminalKind {
3758 NonTerminalKind::ExtensionNameSpace
3759 }
3760 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3761 &self,
3762 tree: &F,
3763 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3764 visit_ignored: &'v mut V,
3765 ) -> Result<O, CstConstructError<E>> {
3766 tree.collect_nodes(
3767 self.0,
3768 [
3769 NodeKind::NonTerminal(NonTerminalKind::Ext),
3770 NodeKind::NonTerminal(NonTerminalKind::KeyIdent),
3771 ],
3772 |[ext, key_ident], visit_ignored| {
3773 Ok(visit(
3774 ExtensionNameSpaceView {
3775 ext: ExtHandle(ext),
3776 key_ident: KeyIdentHandle(key_ident),
3777 },
3778 visit_ignored,
3779 ))
3780 },
3781 visit_ignored,
3782 )
3783 }
3784}
3785#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3786pub struct ExtensionNameSpaceView {
3787 pub ext: ExtHandle,
3788 pub key_ident: KeyIdentHandle,
3789}
3790impl ExtensionNameSpaceView {}
3791#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3792pub struct FalseHandle(pub(crate) super::tree::CstNodeId);
3793impl NonTerminalHandle for FalseHandle {
3794 type View = FalseView;
3795 fn node_id(&self) -> CstNodeId {
3796 self.0
3797 }
3798 fn new_with_visit<F: CstFacade, E>(
3799 index: CstNodeId,
3800 tree: &F,
3801 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3802 ) -> Result<Self, CstConstructError<E>> {
3803 tree.collect_nodes(
3804 index,
3805 [NodeKind::NonTerminal(NonTerminalKind::False)],
3806 |[index], visit| Ok((Self(index), visit)),
3807 visit_ignored,
3808 )
3809 }
3810 fn kind(&self) -> NonTerminalKind {
3811 NonTerminalKind::False
3812 }
3813 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3814 &self,
3815 tree: &F,
3816 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3817 visit_ignored: &'v mut V,
3818 ) -> Result<O, CstConstructError<E>> {
3819 tree.collect_nodes(
3820 self.0,
3821 [NodeKind::Terminal(TerminalKind::False)],
3822 |[r#false], visit_ignored| {
3823 Ok(visit(
3824 FalseView {
3825 r#false: False(r#false),
3826 },
3827 visit_ignored,
3828 ))
3829 },
3830 visit_ignored,
3831 )
3832 }
3833}
3834#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3835pub struct FalseView {
3836 pub r#false: False,
3837}
3838impl FalseView {}
3839#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3840pub struct FloatHandle(pub(crate) super::tree::CstNodeId);
3841impl NonTerminalHandle for FloatHandle {
3842 type View = FloatView;
3843 fn node_id(&self) -> CstNodeId {
3844 self.0
3845 }
3846 fn new_with_visit<F: CstFacade, E>(
3847 index: CstNodeId,
3848 tree: &F,
3849 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3850 ) -> Result<Self, CstConstructError<E>> {
3851 tree.collect_nodes(
3852 index,
3853 [NodeKind::NonTerminal(NonTerminalKind::Float)],
3854 |[index], visit| Ok((Self(index), visit)),
3855 visit_ignored,
3856 )
3857 }
3858 fn kind(&self) -> NonTerminalKind {
3859 NonTerminalKind::Float
3860 }
3861 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3862 &self,
3863 tree: &F,
3864 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3865 visit_ignored: &'v mut V,
3866 ) -> Result<O, CstConstructError<E>> {
3867 tree.collect_nodes(
3868 self.0,
3869 [NodeKind::Terminal(TerminalKind::Float)],
3870 |[float], visit_ignored| {
3871 Ok(visit(
3872 FloatView {
3873 float: Float(float),
3874 },
3875 visit_ignored,
3876 ))
3877 },
3878 visit_ignored,
3879 )
3880 }
3881}
3882#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3883pub struct FloatView {
3884 pub float: Float,
3885}
3886impl FloatView {}
3887#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3888pub struct GrammarNewlineHandle(pub(crate) super::tree::CstNodeId);
3889impl NonTerminalHandle for GrammarNewlineHandle {
3890 type View = GrammarNewlineView;
3891 fn node_id(&self) -> CstNodeId {
3892 self.0
3893 }
3894 fn new_with_visit<F: CstFacade, E>(
3895 index: CstNodeId,
3896 tree: &F,
3897 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3898 ) -> Result<Self, CstConstructError<E>> {
3899 tree.collect_nodes(
3900 index,
3901 [NodeKind::NonTerminal(NonTerminalKind::GrammarNewline)],
3902 |[index], visit| Ok((Self(index), visit)),
3903 visit_ignored,
3904 )
3905 }
3906 fn kind(&self) -> NonTerminalKind {
3907 NonTerminalKind::GrammarNewline
3908 }
3909 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3910 &self,
3911 tree: &F,
3912 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3913 visit_ignored: &'v mut V,
3914 ) -> Result<O, CstConstructError<E>> {
3915 tree.collect_nodes(
3916 self.0,
3917 [NodeKind::Terminal(TerminalKind::GrammarNewline)],
3918 |[grammar_newline], visit_ignored| {
3919 Ok(visit(
3920 GrammarNewlineView {
3921 grammar_newline: GrammarNewline(grammar_newline),
3922 },
3923 visit_ignored,
3924 ))
3925 },
3926 visit_ignored,
3927 )
3928 }
3929}
3930#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3931pub struct GrammarNewlineView {
3932 pub grammar_newline: GrammarNewline,
3933}
3934impl GrammarNewlineView {}
3935#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3936pub struct HoleHandle(pub(crate) super::tree::CstNodeId);
3937impl NonTerminalHandle for HoleHandle {
3938 type View = HoleView;
3939 fn node_id(&self) -> CstNodeId {
3940 self.0
3941 }
3942 fn new_with_visit<F: CstFacade, E>(
3943 index: CstNodeId,
3944 tree: &F,
3945 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3946 ) -> Result<Self, CstConstructError<E>> {
3947 tree.collect_nodes(
3948 index,
3949 [NodeKind::NonTerminal(NonTerminalKind::Hole)],
3950 |[index], visit| Ok((Self(index), visit)),
3951 visit_ignored,
3952 )
3953 }
3954 fn kind(&self) -> NonTerminalKind {
3955 NonTerminalKind::Hole
3956 }
3957 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3958 &self,
3959 tree: &F,
3960 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3961 visit_ignored: &'v mut V,
3962 ) -> Result<O, CstConstructError<E>> {
3963 tree.collect_nodes(
3964 self.0,
3965 [NodeKind::Terminal(TerminalKind::Hole)],
3966 |[hole], visit_ignored| Ok(visit(HoleView { hole: Hole(hole) }, visit_ignored)),
3967 visit_ignored,
3968 )
3969 }
3970}
3971#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3972pub struct HoleView {
3973 pub hole: Hole,
3974}
3975impl HoleView {}
3976#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3977pub struct IdentHandle(pub(crate) super::tree::CstNodeId);
3978impl NonTerminalHandle for IdentHandle {
3979 type View = IdentView;
3980 fn node_id(&self) -> CstNodeId {
3981 self.0
3982 }
3983 fn new_with_visit<F: CstFacade, E>(
3984 index: CstNodeId,
3985 tree: &F,
3986 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3987 ) -> Result<Self, CstConstructError<E>> {
3988 tree.collect_nodes(
3989 index,
3990 [NodeKind::NonTerminal(NonTerminalKind::Ident)],
3991 |[index], visit| Ok((Self(index), visit)),
3992 visit_ignored,
3993 )
3994 }
3995 fn kind(&self) -> NonTerminalKind {
3996 NonTerminalKind::Ident
3997 }
3998 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3999 &self,
4000 tree: &F,
4001 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4002 visit_ignored: &'v mut V,
4003 ) -> Result<O, CstConstructError<E>> {
4004 tree.collect_nodes(
4005 self.0,
4006 [NodeKind::Terminal(TerminalKind::Ident)],
4007 |[ident], visit_ignored| {
4008 Ok(visit(
4009 IdentView {
4010 ident: Ident(ident),
4011 },
4012 visit_ignored,
4013 ))
4014 },
4015 visit_ignored,
4016 )
4017 }
4018}
4019#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4020pub struct IdentView {
4021 pub ident: Ident,
4022}
4023impl IdentView {}
4024#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4025pub struct InfHandle(pub(crate) super::tree::CstNodeId);
4026impl NonTerminalHandle for InfHandle {
4027 type View = InfView;
4028 fn node_id(&self) -> CstNodeId {
4029 self.0
4030 }
4031 fn new_with_visit<F: CstFacade, E>(
4032 index: CstNodeId,
4033 tree: &F,
4034 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4035 ) -> Result<Self, CstConstructError<E>> {
4036 tree.collect_nodes(
4037 index,
4038 [NodeKind::NonTerminal(NonTerminalKind::Inf)],
4039 |[index], visit| Ok((Self(index), visit)),
4040 visit_ignored,
4041 )
4042 }
4043 fn kind(&self) -> NonTerminalKind {
4044 NonTerminalKind::Inf
4045 }
4046 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4047 &self,
4048 tree: &F,
4049 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4050 visit_ignored: &'v mut V,
4051 ) -> Result<O, CstConstructError<E>> {
4052 tree.collect_nodes(
4053 self.0,
4054 [NodeKind::Terminal(TerminalKind::Inf)],
4055 |[inf], visit_ignored| Ok(visit(InfView { inf: Inf(inf) }, visit_ignored)),
4056 visit_ignored,
4057 )
4058 }
4059}
4060#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4061pub struct InfView {
4062 pub inf: Inf,
4063}
4064impl InfView {}
4065#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4066pub struct InlineCodeHandle(pub(crate) super::tree::CstNodeId);
4067impl NonTerminalHandle for InlineCodeHandle {
4068 type View = InlineCodeView;
4069 fn node_id(&self) -> CstNodeId {
4070 self.0
4071 }
4072 fn new_with_visit<F: CstFacade, E>(
4073 index: CstNodeId,
4074 tree: &F,
4075 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4076 ) -> Result<Self, CstConstructError<E>> {
4077 tree.collect_nodes(
4078 index,
4079 [NodeKind::NonTerminal(NonTerminalKind::InlineCode)],
4080 |[index], visit| Ok((Self(index), visit)),
4081 visit_ignored,
4082 )
4083 }
4084 fn kind(&self) -> NonTerminalKind {
4085 NonTerminalKind::InlineCode
4086 }
4087 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4088 &self,
4089 tree: &F,
4090 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4091 visit_ignored: &'v mut V,
4092 ) -> Result<O, CstConstructError<E>> {
4093 let mut children = tree.children(self.0);
4094 let Some(child) = children.next() else {
4095 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4096 };
4097 let Some(child_data) = tree.node_data(child) else {
4098 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4099 };
4100 let variant = match child_data.node_kind() {
4101 NodeKind::NonTerminal(NonTerminalKind::DelimCode) => {
4102 InlineCodeView::DelimCode(DelimCodeHandle(child))
4103 }
4104 NodeKind::NonTerminal(NonTerminalKind::InlineCode1) => {
4105 InlineCodeView::InlineCode1(InlineCode1Handle(child))
4106 }
4107 _ => {
4108 return Err(ViewConstructionError::UnexpectedNode {
4109 node: child,
4110 data: child_data,
4111 expected_kind: child_data.node_kind(),
4112 });
4113 }
4114 };
4115 let (result, _visit) = visit(variant, visit_ignored);
4116 if let Some(extra_child) = children.next() {
4117 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4118 }
4119 Ok(result)
4120 }
4121}
4122#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4123pub enum InlineCodeView {
4124 DelimCode(DelimCodeHandle),
4125 InlineCode1(InlineCode1Handle),
4126}
4127impl InlineCodeView {}
4128#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4129pub struct InlineCode1Handle(pub(crate) super::tree::CstNodeId);
4130impl NonTerminalHandle for InlineCode1Handle {
4131 type View = InlineCode1View;
4132 fn node_id(&self) -> CstNodeId {
4133 self.0
4134 }
4135 fn new_with_visit<F: CstFacade, E>(
4136 index: CstNodeId,
4137 tree: &F,
4138 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4139 ) -> Result<Self, CstConstructError<E>> {
4140 tree.collect_nodes(
4141 index,
4142 [NodeKind::NonTerminal(NonTerminalKind::InlineCode1)],
4143 |[index], visit| Ok((Self(index), visit)),
4144 visit_ignored,
4145 )
4146 }
4147 fn kind(&self) -> NonTerminalKind {
4148 NonTerminalKind::InlineCode1
4149 }
4150 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4151 &self,
4152 tree: &F,
4153 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4154 visit_ignored: &'v mut V,
4155 ) -> Result<O, CstConstructError<E>> {
4156 tree.collect_nodes(
4157 self.0,
4158 [NodeKind::Terminal(TerminalKind::InlineCode1)],
4159 |[inline_code_1], visit_ignored| {
4160 Ok(visit(
4161 InlineCode1View {
4162 inline_code_1: InlineCode1(inline_code_1),
4163 },
4164 visit_ignored,
4165 ))
4166 },
4167 visit_ignored,
4168 )
4169 }
4170}
4171#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4172pub struct InlineCode1View {
4173 pub inline_code_1: InlineCode1,
4174}
4175impl InlineCode1View {}
4176#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4177pub struct IntegerHandle(pub(crate) super::tree::CstNodeId);
4178impl NonTerminalHandle for IntegerHandle {
4179 type View = IntegerView;
4180 fn node_id(&self) -> CstNodeId {
4181 self.0
4182 }
4183 fn new_with_visit<F: CstFacade, E>(
4184 index: CstNodeId,
4185 tree: &F,
4186 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4187 ) -> Result<Self, CstConstructError<E>> {
4188 tree.collect_nodes(
4189 index,
4190 [NodeKind::NonTerminal(NonTerminalKind::Integer)],
4191 |[index], visit| Ok((Self(index), visit)),
4192 visit_ignored,
4193 )
4194 }
4195 fn kind(&self) -> NonTerminalKind {
4196 NonTerminalKind::Integer
4197 }
4198 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4199 &self,
4200 tree: &F,
4201 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4202 visit_ignored: &'v mut V,
4203 ) -> Result<O, CstConstructError<E>> {
4204 tree.collect_nodes(
4205 self.0,
4206 [NodeKind::Terminal(TerminalKind::Integer)],
4207 |[integer], visit_ignored| {
4208 Ok(visit(
4209 IntegerView {
4210 integer: Integer(integer),
4211 },
4212 visit_ignored,
4213 ))
4214 },
4215 visit_ignored,
4216 )
4217 }
4218}
4219#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4220pub struct IntegerView {
4221 pub integer: Integer,
4222}
4223impl IntegerView {}
4224#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4225pub struct KeyHandle(pub(crate) super::tree::CstNodeId);
4226impl NonTerminalHandle for KeyHandle {
4227 type View = KeyView;
4228 fn node_id(&self) -> CstNodeId {
4229 self.0
4230 }
4231 fn new_with_visit<F: CstFacade, E>(
4232 index: CstNodeId,
4233 tree: &F,
4234 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4235 ) -> Result<Self, CstConstructError<E>> {
4236 tree.collect_nodes(
4237 index,
4238 [NodeKind::NonTerminal(NonTerminalKind::Key)],
4239 |[index], visit| Ok((Self(index), visit)),
4240 visit_ignored,
4241 )
4242 }
4243 fn kind(&self) -> NonTerminalKind {
4244 NonTerminalKind::Key
4245 }
4246 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4247 &self,
4248 tree: &F,
4249 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4250 visit_ignored: &'v mut V,
4251 ) -> Result<O, CstConstructError<E>> {
4252 tree.collect_nodes(
4253 self.0,
4254 [
4255 NodeKind::NonTerminal(NonTerminalKind::KeyBase),
4256 NodeKind::NonTerminal(NonTerminalKind::KeyOpt),
4257 ],
4258 |[key_base, key_opt], visit_ignored| {
4259 Ok(visit(
4260 KeyView {
4261 key_base: KeyBaseHandle(key_base),
4262 key_opt: KeyOptHandle(key_opt),
4263 },
4264 visit_ignored,
4265 ))
4266 },
4267 visit_ignored,
4268 )
4269 }
4270}
4271#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4272pub struct KeyView {
4273 pub key_base: KeyBaseHandle,
4274 pub key_opt: KeyOptHandle,
4275}
4276impl KeyView {}
4277#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4278pub struct KeyBaseHandle(pub(crate) super::tree::CstNodeId);
4279impl NonTerminalHandle for KeyBaseHandle {
4280 type View = KeyBaseView;
4281 fn node_id(&self) -> CstNodeId {
4282 self.0
4283 }
4284 fn new_with_visit<F: CstFacade, E>(
4285 index: CstNodeId,
4286 tree: &F,
4287 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4288 ) -> Result<Self, CstConstructError<E>> {
4289 tree.collect_nodes(
4290 index,
4291 [NodeKind::NonTerminal(NonTerminalKind::KeyBase)],
4292 |[index], visit| Ok((Self(index), visit)),
4293 visit_ignored,
4294 )
4295 }
4296 fn kind(&self) -> NonTerminalKind {
4297 NonTerminalKind::KeyBase
4298 }
4299 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4300 &self,
4301 tree: &F,
4302 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4303 visit_ignored: &'v mut V,
4304 ) -> Result<O, CstConstructError<E>> {
4305 let mut children = tree.children(self.0);
4306 let Some(child) = children.next() else {
4307 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4308 };
4309 let Some(child_data) = tree.node_data(child) else {
4310 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4311 };
4312 let variant = match child_data.node_kind() {
4313 NodeKind::NonTerminal(NonTerminalKind::KeyIdent) => {
4314 KeyBaseView::KeyIdent(KeyIdentHandle(child))
4315 }
4316 NodeKind::NonTerminal(NonTerminalKind::ExtensionNameSpace) => {
4317 KeyBaseView::ExtensionNameSpace(ExtensionNameSpaceHandle(child))
4318 }
4319 NodeKind::NonTerminal(NonTerminalKind::String) => {
4320 KeyBaseView::String(StringHandle(child))
4321 }
4322 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
4323 KeyBaseView::Integer(IntegerHandle(child))
4324 }
4325 NodeKind::NonTerminal(NonTerminalKind::Float) => KeyBaseView::Float(FloatHandle(child)),
4326 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
4327 KeyBaseView::KeyTuple(KeyTupleHandle(child))
4328 }
4329 NodeKind::NonTerminal(NonTerminalKind::TupleIndex) => {
4330 KeyBaseView::TupleIndex(TupleIndexHandle(child))
4331 }
4332 _ => {
4333 return Err(ViewConstructionError::UnexpectedNode {
4334 node: child,
4335 data: child_data,
4336 expected_kind: child_data.node_kind(),
4337 });
4338 }
4339 };
4340 let (result, _visit) = visit(variant, visit_ignored);
4341 if let Some(extra_child) = children.next() {
4342 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4343 }
4344 Ok(result)
4345 }
4346}
4347#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4348pub enum KeyBaseView {
4349 KeyIdent(KeyIdentHandle),
4350 ExtensionNameSpace(ExtensionNameSpaceHandle),
4351 String(StringHandle),
4352 Integer(IntegerHandle),
4353 Float(FloatHandle),
4354 KeyTuple(KeyTupleHandle),
4355 TupleIndex(TupleIndexHandle),
4356}
4357impl KeyBaseView {}
4358#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4359pub struct KeyIdentHandle(pub(crate) super::tree::CstNodeId);
4360impl NonTerminalHandle for KeyIdentHandle {
4361 type View = KeyIdentView;
4362 fn node_id(&self) -> CstNodeId {
4363 self.0
4364 }
4365 fn new_with_visit<F: CstFacade, E>(
4366 index: CstNodeId,
4367 tree: &F,
4368 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4369 ) -> Result<Self, CstConstructError<E>> {
4370 tree.collect_nodes(
4371 index,
4372 [NodeKind::NonTerminal(NonTerminalKind::KeyIdent)],
4373 |[index], visit| Ok((Self(index), visit)),
4374 visit_ignored,
4375 )
4376 }
4377 fn kind(&self) -> NonTerminalKind {
4378 NonTerminalKind::KeyIdent
4379 }
4380 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4381 &self,
4382 tree: &F,
4383 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4384 visit_ignored: &'v mut V,
4385 ) -> Result<O, CstConstructError<E>> {
4386 let mut children = tree.children(self.0);
4387 let Some(child) = children.next() else {
4388 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4389 };
4390 let Some(child_data) = tree.node_data(child) else {
4391 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4392 };
4393 let variant = match child_data.node_kind() {
4394 NodeKind::NonTerminal(NonTerminalKind::Ident) => {
4395 KeyIdentView::Ident(IdentHandle(child))
4396 }
4397 NodeKind::NonTerminal(NonTerminalKind::True) => KeyIdentView::True(TrueHandle(child)),
4398 NodeKind::NonTerminal(NonTerminalKind::False) => {
4399 KeyIdentView::False(FalseHandle(child))
4400 }
4401 NodeKind::NonTerminal(NonTerminalKind::Null) => KeyIdentView::Null(NullHandle(child)),
4402 _ => {
4403 return Err(ViewConstructionError::UnexpectedNode {
4404 node: child,
4405 data: child_data,
4406 expected_kind: child_data.node_kind(),
4407 });
4408 }
4409 };
4410 let (result, _visit) = visit(variant, visit_ignored);
4411 if let Some(extra_child) = children.next() {
4412 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4413 }
4414 Ok(result)
4415 }
4416}
4417#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4418pub enum KeyIdentView {
4419 Ident(IdentHandle),
4420 True(TrueHandle),
4421 False(FalseHandle),
4422 Null(NullHandle),
4423}
4424impl KeyIdentView {}
4425#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4426pub struct KeyOptHandle(pub(crate) super::tree::CstNodeId);
4427impl NonTerminalHandle for KeyOptHandle {
4428 type View = Option<ArrayMarkerHandle>;
4429 fn node_id(&self) -> CstNodeId {
4430 self.0
4431 }
4432 fn new_with_visit<F: CstFacade, E>(
4433 index: CstNodeId,
4434 tree: &F,
4435 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4436 ) -> Result<Self, CstConstructError<E>> {
4437 tree.collect_nodes(
4438 index,
4439 [NodeKind::NonTerminal(NonTerminalKind::KeyOpt)],
4440 |[index], visit| Ok((Self(index), visit)),
4441 visit_ignored,
4442 )
4443 }
4444 fn kind(&self) -> NonTerminalKind {
4445 NonTerminalKind::KeyOpt
4446 }
4447 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4448 &self,
4449 tree: &F,
4450 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4451 visit_ignored: &'v mut V,
4452 ) -> Result<O, CstConstructError<E>> {
4453 if tree.has_no_children(self.0) {
4454 return Ok(visit(None, visit_ignored).0);
4455 }
4456 Ok(visit(
4457 Some(ArrayMarkerHandle::new_with_visit(
4458 self.0,
4459 tree,
4460 visit_ignored,
4461 )?),
4462 visit_ignored,
4463 )
4464 .0)
4465 }
4466}
4467#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4468pub struct KeyTupleHandle(pub(crate) super::tree::CstNodeId);
4469impl NonTerminalHandle for KeyTupleHandle {
4470 type View = KeyTupleView;
4471 fn node_id(&self) -> CstNodeId {
4472 self.0
4473 }
4474 fn new_with_visit<F: CstFacade, E>(
4475 index: CstNodeId,
4476 tree: &F,
4477 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4478 ) -> Result<Self, CstConstructError<E>> {
4479 tree.collect_nodes(
4480 index,
4481 [NodeKind::NonTerminal(NonTerminalKind::KeyTuple)],
4482 |[index], visit| Ok((Self(index), visit)),
4483 visit_ignored,
4484 )
4485 }
4486 fn kind(&self) -> NonTerminalKind {
4487 NonTerminalKind::KeyTuple
4488 }
4489 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4490 &self,
4491 tree: &F,
4492 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4493 visit_ignored: &'v mut V,
4494 ) -> Result<O, CstConstructError<E>> {
4495 tree.collect_nodes(
4496 self.0,
4497 [
4498 NodeKind::NonTerminal(NonTerminalKind::LParen),
4499 NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt),
4500 NodeKind::NonTerminal(NonTerminalKind::RParen),
4501 ],
4502 |[l_paren, key_tuple_opt, r_paren], visit_ignored| {
4503 Ok(visit(
4504 KeyTupleView {
4505 l_paren: LParenHandle(l_paren),
4506 key_tuple_opt: KeyTupleOptHandle(key_tuple_opt),
4507 r_paren: RParenHandle(r_paren),
4508 },
4509 visit_ignored,
4510 ))
4511 },
4512 visit_ignored,
4513 )
4514 }
4515}
4516#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4517pub struct KeyTupleView {
4518 pub l_paren: LParenHandle,
4519 pub key_tuple_opt: KeyTupleOptHandle,
4520 pub r_paren: RParenHandle,
4521}
4522impl KeyTupleView {}
4523#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4524pub struct KeyTupleElementsHandle(pub(crate) super::tree::CstNodeId);
4525impl NonTerminalHandle for KeyTupleElementsHandle {
4526 type View = KeyTupleElementsView;
4527 fn node_id(&self) -> CstNodeId {
4528 self.0
4529 }
4530 fn new_with_visit<F: CstFacade, E>(
4531 index: CstNodeId,
4532 tree: &F,
4533 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4534 ) -> Result<Self, CstConstructError<E>> {
4535 tree.collect_nodes(
4536 index,
4537 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElements)],
4538 |[index], visit| Ok((Self(index), visit)),
4539 visit_ignored,
4540 )
4541 }
4542 fn kind(&self) -> NonTerminalKind {
4543 NonTerminalKind::KeyTupleElements
4544 }
4545 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4546 &self,
4547 tree: &F,
4548 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4549 visit_ignored: &'v mut V,
4550 ) -> Result<O, CstConstructError<E>> {
4551 tree.collect_nodes(
4552 self.0,
4553 [
4554 NodeKind::NonTerminal(NonTerminalKind::KeyValue),
4555 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt),
4556 ],
4557 |[key_value, key_tuple_elements_opt], visit_ignored| {
4558 Ok(visit(
4559 KeyTupleElementsView {
4560 key_value: KeyValueHandle(key_value),
4561 key_tuple_elements_opt: KeyTupleElementsOptHandle(key_tuple_elements_opt),
4562 },
4563 visit_ignored,
4564 ))
4565 },
4566 visit_ignored,
4567 )
4568 }
4569}
4570#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4571pub struct KeyTupleElementsView {
4572 pub key_value: KeyValueHandle,
4573 pub key_tuple_elements_opt: KeyTupleElementsOptHandle,
4574}
4575impl KeyTupleElementsView {}
4576#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4577pub struct KeyTupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
4578impl NonTerminalHandle for KeyTupleElementsOptHandle {
4579 type View = Option<KeyTupleElementsTailHandle>;
4580 fn node_id(&self) -> CstNodeId {
4581 self.0
4582 }
4583 fn new_with_visit<F: CstFacade, E>(
4584 index: CstNodeId,
4585 tree: &F,
4586 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4587 ) -> Result<Self, CstConstructError<E>> {
4588 tree.collect_nodes(
4589 index,
4590 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt)],
4591 |[index], visit| Ok((Self(index), visit)),
4592 visit_ignored,
4593 )
4594 }
4595 fn kind(&self) -> NonTerminalKind {
4596 NonTerminalKind::KeyTupleElementsOpt
4597 }
4598 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4599 &self,
4600 tree: &F,
4601 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4602 visit_ignored: &'v mut V,
4603 ) -> Result<O, CstConstructError<E>> {
4604 if tree.has_no_children(self.0) {
4605 return Ok(visit(None, visit_ignored).0);
4606 }
4607 Ok(visit(
4608 Some(KeyTupleElementsTailHandle::new_with_visit(
4609 self.0,
4610 tree,
4611 visit_ignored,
4612 )?),
4613 visit_ignored,
4614 )
4615 .0)
4616 }
4617}
4618#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4619pub struct KeyTupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
4620impl NonTerminalHandle for KeyTupleElementsTailHandle {
4621 type View = KeyTupleElementsTailView;
4622 fn node_id(&self) -> CstNodeId {
4623 self.0
4624 }
4625 fn new_with_visit<F: CstFacade, E>(
4626 index: CstNodeId,
4627 tree: &F,
4628 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4629 ) -> Result<Self, CstConstructError<E>> {
4630 tree.collect_nodes(
4631 index,
4632 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTail)],
4633 |[index], visit| Ok((Self(index), visit)),
4634 visit_ignored,
4635 )
4636 }
4637 fn kind(&self) -> NonTerminalKind {
4638 NonTerminalKind::KeyTupleElementsTail
4639 }
4640 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4641 &self,
4642 tree: &F,
4643 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4644 visit_ignored: &'v mut V,
4645 ) -> Result<O, CstConstructError<E>> {
4646 tree.collect_nodes(
4647 self.0,
4648 [
4649 NodeKind::NonTerminal(NonTerminalKind::Comma),
4650 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTailOpt),
4651 ],
4652 |[comma, key_tuple_elements_tail_opt], visit_ignored| {
4653 Ok(visit(
4654 KeyTupleElementsTailView {
4655 comma: CommaHandle(comma),
4656 key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle(
4657 key_tuple_elements_tail_opt,
4658 ),
4659 },
4660 visit_ignored,
4661 ))
4662 },
4663 visit_ignored,
4664 )
4665 }
4666}
4667#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4668pub struct KeyTupleElementsTailView {
4669 pub comma: CommaHandle,
4670 pub key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle,
4671}
4672impl KeyTupleElementsTailView {}
4673#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4674pub struct KeyTupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
4675impl NonTerminalHandle for KeyTupleElementsTailOptHandle {
4676 type View = Option<KeyTupleElementsHandle>;
4677 fn node_id(&self) -> CstNodeId {
4678 self.0
4679 }
4680 fn new_with_visit<F: CstFacade, E>(
4681 index: CstNodeId,
4682 tree: &F,
4683 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4684 ) -> Result<Self, CstConstructError<E>> {
4685 tree.collect_nodes(
4686 index,
4687 [NodeKind::NonTerminal(
4688 NonTerminalKind::KeyTupleElementsTailOpt,
4689 )],
4690 |[index], visit| Ok((Self(index), visit)),
4691 visit_ignored,
4692 )
4693 }
4694 fn kind(&self) -> NonTerminalKind {
4695 NonTerminalKind::KeyTupleElementsTailOpt
4696 }
4697 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4698 &self,
4699 tree: &F,
4700 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4701 visit_ignored: &'v mut V,
4702 ) -> Result<O, CstConstructError<E>> {
4703 if tree.has_no_children(self.0) {
4704 return Ok(visit(None, visit_ignored).0);
4705 }
4706 Ok(visit(
4707 Some(KeyTupleElementsHandle::new_with_visit(
4708 self.0,
4709 tree,
4710 visit_ignored,
4711 )?),
4712 visit_ignored,
4713 )
4714 .0)
4715 }
4716}
4717#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4718pub struct KeyTupleOptHandle(pub(crate) super::tree::CstNodeId);
4719impl NonTerminalHandle for KeyTupleOptHandle {
4720 type View = Option<KeyTupleElementsHandle>;
4721 fn node_id(&self) -> CstNodeId {
4722 self.0
4723 }
4724 fn new_with_visit<F: CstFacade, E>(
4725 index: CstNodeId,
4726 tree: &F,
4727 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4728 ) -> Result<Self, CstConstructError<E>> {
4729 tree.collect_nodes(
4730 index,
4731 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt)],
4732 |[index], visit| Ok((Self(index), visit)),
4733 visit_ignored,
4734 )
4735 }
4736 fn kind(&self) -> NonTerminalKind {
4737 NonTerminalKind::KeyTupleOpt
4738 }
4739 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4740 &self,
4741 tree: &F,
4742 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4743 visit_ignored: &'v mut V,
4744 ) -> Result<O, CstConstructError<E>> {
4745 if tree.has_no_children(self.0) {
4746 return Ok(visit(None, visit_ignored).0);
4747 }
4748 Ok(visit(
4749 Some(KeyTupleElementsHandle::new_with_visit(
4750 self.0,
4751 tree,
4752 visit_ignored,
4753 )?),
4754 visit_ignored,
4755 )
4756 .0)
4757 }
4758}
4759#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4760pub struct KeyValueHandle(pub(crate) super::tree::CstNodeId);
4761impl NonTerminalHandle for KeyValueHandle {
4762 type View = KeyValueView;
4763 fn node_id(&self) -> CstNodeId {
4764 self.0
4765 }
4766 fn new_with_visit<F: CstFacade, E>(
4767 index: CstNodeId,
4768 tree: &F,
4769 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4770 ) -> Result<Self, CstConstructError<E>> {
4771 tree.collect_nodes(
4772 index,
4773 [NodeKind::NonTerminal(NonTerminalKind::KeyValue)],
4774 |[index], visit| Ok((Self(index), visit)),
4775 visit_ignored,
4776 )
4777 }
4778 fn kind(&self) -> NonTerminalKind {
4779 NonTerminalKind::KeyValue
4780 }
4781 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4782 &self,
4783 tree: &F,
4784 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4785 visit_ignored: &'v mut V,
4786 ) -> Result<O, CstConstructError<E>> {
4787 let mut children = tree.children(self.0);
4788 let Some(child) = children.next() else {
4789 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4790 };
4791 let Some(child_data) = tree.node_data(child) else {
4792 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4793 };
4794 let variant = match child_data.node_kind() {
4795 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
4796 KeyValueView::Integer(IntegerHandle(child))
4797 }
4798 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
4799 KeyValueView::Boolean(BooleanHandle(child))
4800 }
4801 NodeKind::NonTerminal(NonTerminalKind::Str) => KeyValueView::Str(StrHandle(child)),
4802 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
4803 KeyValueView::KeyTuple(KeyTupleHandle(child))
4804 }
4805 _ => {
4806 return Err(ViewConstructionError::UnexpectedNode {
4807 node: child,
4808 data: child_data,
4809 expected_kind: child_data.node_kind(),
4810 });
4811 }
4812 };
4813 let (result, _visit) = visit(variant, visit_ignored);
4814 if let Some(extra_child) = children.next() {
4815 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4816 }
4817 Ok(result)
4818 }
4819}
4820#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4821pub enum KeyValueView {
4822 Integer(IntegerHandle),
4823 Boolean(BooleanHandle),
4824 Str(StrHandle),
4825 KeyTuple(KeyTupleHandle),
4826}
4827impl KeyValueView {}
4828#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4829pub struct KeysHandle(pub(crate) super::tree::CstNodeId);
4830impl NonTerminalHandle for KeysHandle {
4831 type View = KeysView;
4832 fn node_id(&self) -> CstNodeId {
4833 self.0
4834 }
4835 fn new_with_visit<F: CstFacade, E>(
4836 index: CstNodeId,
4837 tree: &F,
4838 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4839 ) -> Result<Self, CstConstructError<E>> {
4840 tree.collect_nodes(
4841 index,
4842 [NodeKind::NonTerminal(NonTerminalKind::Keys)],
4843 |[index], visit| Ok((Self(index), visit)),
4844 visit_ignored,
4845 )
4846 }
4847 fn kind(&self) -> NonTerminalKind {
4848 NonTerminalKind::Keys
4849 }
4850 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4851 &self,
4852 tree: &F,
4853 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4854 visit_ignored: &'v mut V,
4855 ) -> Result<O, CstConstructError<E>> {
4856 tree.collect_nodes(
4857 self.0,
4858 [
4859 NodeKind::NonTerminal(NonTerminalKind::Key),
4860 NodeKind::NonTerminal(NonTerminalKind::KeysList),
4861 ],
4862 |[key, keys_list], visit_ignored| {
4863 Ok(visit(
4864 KeysView {
4865 key: KeyHandle(key),
4866 keys_list: KeysListHandle(keys_list),
4867 },
4868 visit_ignored,
4869 ))
4870 },
4871 visit_ignored,
4872 )
4873 }
4874}
4875#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4876pub struct KeysView {
4877 pub key: KeyHandle,
4878 pub keys_list: KeysListHandle,
4879}
4880impl KeysView {}
4881#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4882pub struct KeysListHandle(pub(crate) super::tree::CstNodeId);
4883impl NonTerminalHandle for KeysListHandle {
4884 type View = Option<KeysListView>;
4885 fn node_id(&self) -> CstNodeId {
4886 self.0
4887 }
4888 fn new_with_visit<F: CstFacade, E>(
4889 index: CstNodeId,
4890 tree: &F,
4891 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4892 ) -> Result<Self, CstConstructError<E>> {
4893 tree.collect_nodes(
4894 index,
4895 [NodeKind::NonTerminal(NonTerminalKind::KeysList)],
4896 |[index], visit| Ok((Self(index), visit)),
4897 visit_ignored,
4898 )
4899 }
4900 fn kind(&self) -> NonTerminalKind {
4901 NonTerminalKind::KeysList
4902 }
4903 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4904 &self,
4905 tree: &F,
4906 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4907 visit_ignored: &'v mut V,
4908 ) -> Result<O, CstConstructError<E>> {
4909 if tree.has_no_children(self.0) {
4910 return Ok(visit(None, visit_ignored).0);
4911 }
4912 tree.collect_nodes(
4913 self.0,
4914 [
4915 NodeKind::NonTerminal(NonTerminalKind::Dot),
4916 NodeKind::NonTerminal(NonTerminalKind::Key),
4917 NodeKind::NonTerminal(NonTerminalKind::KeysList),
4918 ],
4919 |[dot, key, keys_list], visit_ignored| {
4920 Ok(visit(
4921 Some(KeysListView {
4922 dot: DotHandle(dot),
4923 key: KeyHandle(key),
4924 keys_list: KeysListHandle(keys_list),
4925 }),
4926 visit_ignored,
4927 ))
4928 },
4929 visit_ignored,
4930 )
4931 }
4932}
4933#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4934pub struct KeysListView {
4935 pub dot: DotHandle,
4936 pub key: KeyHandle,
4937 pub keys_list: KeysListHandle,
4938}
4939impl<F: CstFacade> RecursiveView<F> for KeysListView {
4940 type Item = KeysListItem;
4941 fn get_all_with_visit<E>(
4942 &self,
4943 tree: &F,
4944 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4945 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
4946 let mut items = Vec::new();
4947 let mut current_view = Some(*self);
4948 while let Some(item) = current_view {
4949 let Self { dot, key, .. } = item;
4950 items.push(KeysListItem { dot, key });
4951 item.keys_list.get_view_with_visit(
4952 tree,
4953 |view, visit_ignored| {
4954 current_view = view;
4955 ((), visit_ignored)
4956 },
4957 visit_ignored,
4958 )?;
4959 }
4960 Ok(items)
4961 }
4962}
4963#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4964pub struct KeysListItem {
4965 pub dot: DotHandle,
4966 pub key: KeyHandle,
4967}
4968#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4969pub struct LParenHandle(pub(crate) super::tree::CstNodeId);
4970impl NonTerminalHandle for LParenHandle {
4971 type View = LParenView;
4972 fn node_id(&self) -> CstNodeId {
4973 self.0
4974 }
4975 fn new_with_visit<F: CstFacade, E>(
4976 index: CstNodeId,
4977 tree: &F,
4978 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4979 ) -> Result<Self, CstConstructError<E>> {
4980 tree.collect_nodes(
4981 index,
4982 [NodeKind::NonTerminal(NonTerminalKind::LParen)],
4983 |[index], visit| Ok((Self(index), visit)),
4984 visit_ignored,
4985 )
4986 }
4987 fn kind(&self) -> NonTerminalKind {
4988 NonTerminalKind::LParen
4989 }
4990 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4991 &self,
4992 tree: &F,
4993 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4994 visit_ignored: &'v mut V,
4995 ) -> Result<O, CstConstructError<E>> {
4996 tree.collect_nodes(
4997 self.0,
4998 [NodeKind::Terminal(TerminalKind::LParen)],
4999 |[l_paren], visit_ignored| {
5000 Ok(visit(
5001 LParenView {
5002 l_paren: LParen(l_paren),
5003 },
5004 visit_ignored,
5005 ))
5006 },
5007 visit_ignored,
5008 )
5009 }
5010}
5011#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5012pub struct LParenView {
5013 pub l_paren: LParen,
5014}
5015impl LParenView {}
5016#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5017pub struct LitStrHandle(pub(crate) super::tree::CstNodeId);
5018impl NonTerminalHandle for LitStrHandle {
5019 type View = LitStrView;
5020 fn node_id(&self) -> CstNodeId {
5021 self.0
5022 }
5023 fn new_with_visit<F: CstFacade, E>(
5024 index: CstNodeId,
5025 tree: &F,
5026 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5027 ) -> Result<Self, CstConstructError<E>> {
5028 tree.collect_nodes(
5029 index,
5030 [NodeKind::NonTerminal(NonTerminalKind::LitStr)],
5031 |[index], visit| Ok((Self(index), visit)),
5032 visit_ignored,
5033 )
5034 }
5035 fn kind(&self) -> NonTerminalKind {
5036 NonTerminalKind::LitStr
5037 }
5038 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5039 &self,
5040 tree: &F,
5041 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5042 visit_ignored: &'v mut V,
5043 ) -> Result<O, CstConstructError<E>> {
5044 tree.collect_nodes(
5045 self.0,
5046 [NodeKind::Terminal(TerminalKind::LitStr)],
5047 |[lit_str], visit_ignored| {
5048 Ok(visit(
5049 LitStrView {
5050 lit_str: LitStr(lit_str),
5051 },
5052 visit_ignored,
5053 ))
5054 },
5055 visit_ignored,
5056 )
5057 }
5058}
5059#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5060pub struct LitStrView {
5061 pub lit_str: LitStr,
5062}
5063impl LitStrView {}
5064#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5065pub struct LitStr1Handle(pub(crate) super::tree::CstNodeId);
5066impl NonTerminalHandle for LitStr1Handle {
5067 type View = LitStr1View;
5068 fn node_id(&self) -> CstNodeId {
5069 self.0
5070 }
5071 fn new_with_visit<F: CstFacade, E>(
5072 index: CstNodeId,
5073 tree: &F,
5074 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5075 ) -> Result<Self, CstConstructError<E>> {
5076 tree.collect_nodes(
5077 index,
5078 [NodeKind::NonTerminal(NonTerminalKind::LitStr1)],
5079 |[index], visit| Ok((Self(index), visit)),
5080 visit_ignored,
5081 )
5082 }
5083 fn kind(&self) -> NonTerminalKind {
5084 NonTerminalKind::LitStr1
5085 }
5086 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5087 &self,
5088 tree: &F,
5089 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5090 visit_ignored: &'v mut V,
5091 ) -> Result<O, CstConstructError<E>> {
5092 tree.collect_nodes(
5093 self.0,
5094 [
5095 NodeKind::NonTerminal(NonTerminalKind::LitStr1Start),
5096 NodeKind::NonTerminal(NonTerminalKind::LitStr1List),
5097 NodeKind::NonTerminal(NonTerminalKind::LitStr1End),
5098 ],
5099 |[lit_str_1_start, lit_str_1_list, lit_str_1_end], visit_ignored| {
5100 Ok(visit(
5101 LitStr1View {
5102 lit_str_1_start: LitStr1StartHandle(lit_str_1_start),
5103 lit_str_1_list: LitStr1ListHandle(lit_str_1_list),
5104 lit_str_1_end: LitStr1EndHandle(lit_str_1_end),
5105 },
5106 visit_ignored,
5107 ))
5108 },
5109 visit_ignored,
5110 )
5111 }
5112}
5113#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5114pub struct LitStr1View {
5115 pub lit_str_1_start: LitStr1StartHandle,
5116 pub lit_str_1_list: LitStr1ListHandle,
5117 pub lit_str_1_end: LitStr1EndHandle,
5118}
5119impl LitStr1View {}
5120#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5121pub struct LitStr1EndHandle(pub(crate) super::tree::CstNodeId);
5122impl NonTerminalHandle for LitStr1EndHandle {
5123 type View = LitStr1EndView;
5124 fn node_id(&self) -> CstNodeId {
5125 self.0
5126 }
5127 fn new_with_visit<F: CstFacade, E>(
5128 index: CstNodeId,
5129 tree: &F,
5130 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5131 ) -> Result<Self, CstConstructError<E>> {
5132 tree.collect_nodes(
5133 index,
5134 [NodeKind::NonTerminal(NonTerminalKind::LitStr1End)],
5135 |[index], visit| Ok((Self(index), visit)),
5136 visit_ignored,
5137 )
5138 }
5139 fn kind(&self) -> NonTerminalKind {
5140 NonTerminalKind::LitStr1End
5141 }
5142 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5143 &self,
5144 tree: &F,
5145 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5146 visit_ignored: &'v mut V,
5147 ) -> Result<O, CstConstructError<E>> {
5148 tree.collect_nodes(
5149 self.0,
5150 [NodeKind::Terminal(TerminalKind::LitStr1End)],
5151 |[lit_str_1_end], visit_ignored| {
5152 Ok(visit(
5153 LitStr1EndView {
5154 lit_str_1_end: LitStr1End(lit_str_1_end),
5155 },
5156 visit_ignored,
5157 ))
5158 },
5159 visit_ignored,
5160 )
5161 }
5162}
5163#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5164pub struct LitStr1EndView {
5165 pub lit_str_1_end: LitStr1End,
5166}
5167impl LitStr1EndView {}
5168#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5169pub struct LitStr1ListHandle(pub(crate) super::tree::CstNodeId);
5170impl NonTerminalHandle for LitStr1ListHandle {
5171 type View = Option<LitStr1ListView>;
5172 fn node_id(&self) -> CstNodeId {
5173 self.0
5174 }
5175 fn new_with_visit<F: CstFacade, E>(
5176 index: CstNodeId,
5177 tree: &F,
5178 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5179 ) -> Result<Self, CstConstructError<E>> {
5180 tree.collect_nodes(
5181 index,
5182 [NodeKind::NonTerminal(NonTerminalKind::LitStr1List)],
5183 |[index], visit| Ok((Self(index), visit)),
5184 visit_ignored,
5185 )
5186 }
5187 fn kind(&self) -> NonTerminalKind {
5188 NonTerminalKind::LitStr1List
5189 }
5190 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5191 &self,
5192 tree: &F,
5193 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5194 visit_ignored: &'v mut V,
5195 ) -> Result<O, CstConstructError<E>> {
5196 if tree.has_no_children(self.0) {
5197 return Ok(visit(None, visit_ignored).0);
5198 }
5199 tree.collect_nodes(
5200 self.0,
5201 [
5202 NodeKind::NonTerminal(NonTerminalKind::LitStr1ListGroup),
5203 NodeKind::NonTerminal(NonTerminalKind::LitStr1List),
5204 ],
5205 |[lit_str_1_list_group, lit_str_1_list], visit_ignored| {
5206 Ok(visit(
5207 Some(LitStr1ListView {
5208 lit_str_1_list_group: LitStr1ListGroupHandle(lit_str_1_list_group),
5209 lit_str_1_list: LitStr1ListHandle(lit_str_1_list),
5210 }),
5211 visit_ignored,
5212 ))
5213 },
5214 visit_ignored,
5215 )
5216 }
5217}
5218#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5219pub struct LitStr1ListView {
5220 pub lit_str_1_list_group: LitStr1ListGroupHandle,
5221 pub lit_str_1_list: LitStr1ListHandle,
5222}
5223impl<F: CstFacade> RecursiveView<F> for LitStr1ListView {
5224 type Item = LitStr1ListGroupHandle;
5225 fn get_all_with_visit<E>(
5226 &self,
5227 tree: &F,
5228 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5229 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5230 let mut items = Vec::new();
5231 let mut current_view = Some(*self);
5232 while let Some(item) = current_view {
5233 let Self {
5234 lit_str_1_list_group,
5235 ..
5236 } = item;
5237 items.push(lit_str_1_list_group);
5238 item.lit_str_1_list.get_view_with_visit(
5239 tree,
5240 |view, visit_ignored| {
5241 current_view = view;
5242 ((), visit_ignored)
5243 },
5244 visit_ignored,
5245 )?;
5246 }
5247 Ok(items)
5248 }
5249}
5250#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5251pub struct LitStr1ListGroupHandle(pub(crate) super::tree::CstNodeId);
5252impl NonTerminalHandle for LitStr1ListGroupHandle {
5253 type View = LitStr1ListGroupView;
5254 fn node_id(&self) -> CstNodeId {
5255 self.0
5256 }
5257 fn new_with_visit<F: CstFacade, E>(
5258 index: CstNodeId,
5259 tree: &F,
5260 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5261 ) -> Result<Self, CstConstructError<E>> {
5262 tree.collect_nodes(
5263 index,
5264 [NodeKind::NonTerminal(NonTerminalKind::LitStr1ListGroup)],
5265 |[index], visit| Ok((Self(index), visit)),
5266 visit_ignored,
5267 )
5268 }
5269 fn kind(&self) -> NonTerminalKind {
5270 NonTerminalKind::LitStr1ListGroup
5271 }
5272 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5273 &self,
5274 tree: &F,
5275 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5276 visit_ignored: &'v mut V,
5277 ) -> Result<O, CstConstructError<E>> {
5278 let mut children = tree.children(self.0);
5279 let Some(child) = children.next() else {
5280 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5281 };
5282 let Some(child_data) = tree.node_data(child) else {
5283 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5284 };
5285 let variant = match child_data.node_kind() {
5286 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5287 LitStr1ListGroupView::NoSQuote(NoSQuoteHandle(child))
5288 }
5289 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5290 LitStr1ListGroupView::SQuote(SQuoteHandle(child))
5291 }
5292 _ => {
5293 return Err(ViewConstructionError::UnexpectedNode {
5294 node: child,
5295 data: child_data,
5296 expected_kind: child_data.node_kind(),
5297 });
5298 }
5299 };
5300 let (result, _visit) = visit(variant, visit_ignored);
5301 if let Some(extra_child) = children.next() {
5302 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5303 }
5304 Ok(result)
5305 }
5306}
5307#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5308pub enum LitStr1ListGroupView {
5309 NoSQuote(NoSQuoteHandle),
5310 SQuote(SQuoteHandle),
5311}
5312impl LitStr1ListGroupView {}
5313#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5314pub struct LitStr1StartHandle(pub(crate) super::tree::CstNodeId);
5315impl NonTerminalHandle for LitStr1StartHandle {
5316 type View = LitStr1StartView;
5317 fn node_id(&self) -> CstNodeId {
5318 self.0
5319 }
5320 fn new_with_visit<F: CstFacade, E>(
5321 index: CstNodeId,
5322 tree: &F,
5323 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5324 ) -> Result<Self, CstConstructError<E>> {
5325 tree.collect_nodes(
5326 index,
5327 [NodeKind::NonTerminal(NonTerminalKind::LitStr1Start)],
5328 |[index], visit| Ok((Self(index), visit)),
5329 visit_ignored,
5330 )
5331 }
5332 fn kind(&self) -> NonTerminalKind {
5333 NonTerminalKind::LitStr1Start
5334 }
5335 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5336 &self,
5337 tree: &F,
5338 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5339 visit_ignored: &'v mut V,
5340 ) -> Result<O, CstConstructError<E>> {
5341 tree.collect_nodes(
5342 self.0,
5343 [NodeKind::Terminal(TerminalKind::LitStr1Start)],
5344 |[lit_str_1_start], visit_ignored| {
5345 Ok(visit(
5346 LitStr1StartView {
5347 lit_str_1_start: LitStr1Start(lit_str_1_start),
5348 },
5349 visit_ignored,
5350 ))
5351 },
5352 visit_ignored,
5353 )
5354 }
5355}
5356#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5357pub struct LitStr1StartView {
5358 pub lit_str_1_start: LitStr1Start,
5359}
5360impl LitStr1StartView {}
5361#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5362pub struct LitStr2Handle(pub(crate) super::tree::CstNodeId);
5363impl NonTerminalHandle for LitStr2Handle {
5364 type View = LitStr2View;
5365 fn node_id(&self) -> CstNodeId {
5366 self.0
5367 }
5368 fn new_with_visit<F: CstFacade, E>(
5369 index: CstNodeId,
5370 tree: &F,
5371 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5372 ) -> Result<Self, CstConstructError<E>> {
5373 tree.collect_nodes(
5374 index,
5375 [NodeKind::NonTerminal(NonTerminalKind::LitStr2)],
5376 |[index], visit| Ok((Self(index), visit)),
5377 visit_ignored,
5378 )
5379 }
5380 fn kind(&self) -> NonTerminalKind {
5381 NonTerminalKind::LitStr2
5382 }
5383 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5384 &self,
5385 tree: &F,
5386 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5387 visit_ignored: &'v mut V,
5388 ) -> Result<O, CstConstructError<E>> {
5389 tree.collect_nodes(
5390 self.0,
5391 [
5392 NodeKind::NonTerminal(NonTerminalKind::LitStr2Start),
5393 NodeKind::NonTerminal(NonTerminalKind::LitStr2List),
5394 NodeKind::NonTerminal(NonTerminalKind::LitStr2End),
5395 ],
5396 |[lit_str_2_start, lit_str_2_list, lit_str_2_end], visit_ignored| {
5397 Ok(visit(
5398 LitStr2View {
5399 lit_str_2_start: LitStr2StartHandle(lit_str_2_start),
5400 lit_str_2_list: LitStr2ListHandle(lit_str_2_list),
5401 lit_str_2_end: LitStr2EndHandle(lit_str_2_end),
5402 },
5403 visit_ignored,
5404 ))
5405 },
5406 visit_ignored,
5407 )
5408 }
5409}
5410#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5411pub struct LitStr2View {
5412 pub lit_str_2_start: LitStr2StartHandle,
5413 pub lit_str_2_list: LitStr2ListHandle,
5414 pub lit_str_2_end: LitStr2EndHandle,
5415}
5416impl LitStr2View {}
5417#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5418pub struct LitStr2EndHandle(pub(crate) super::tree::CstNodeId);
5419impl NonTerminalHandle for LitStr2EndHandle {
5420 type View = LitStr2EndView;
5421 fn node_id(&self) -> CstNodeId {
5422 self.0
5423 }
5424 fn new_with_visit<F: CstFacade, E>(
5425 index: CstNodeId,
5426 tree: &F,
5427 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5428 ) -> Result<Self, CstConstructError<E>> {
5429 tree.collect_nodes(
5430 index,
5431 [NodeKind::NonTerminal(NonTerminalKind::LitStr2End)],
5432 |[index], visit| Ok((Self(index), visit)),
5433 visit_ignored,
5434 )
5435 }
5436 fn kind(&self) -> NonTerminalKind {
5437 NonTerminalKind::LitStr2End
5438 }
5439 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5440 &self,
5441 tree: &F,
5442 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5443 visit_ignored: &'v mut V,
5444 ) -> Result<O, CstConstructError<E>> {
5445 tree.collect_nodes(
5446 self.0,
5447 [NodeKind::Terminal(TerminalKind::LitStr2End)],
5448 |[lit_str_2_end], visit_ignored| {
5449 Ok(visit(
5450 LitStr2EndView {
5451 lit_str_2_end: LitStr2End(lit_str_2_end),
5452 },
5453 visit_ignored,
5454 ))
5455 },
5456 visit_ignored,
5457 )
5458 }
5459}
5460#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5461pub struct LitStr2EndView {
5462 pub lit_str_2_end: LitStr2End,
5463}
5464impl LitStr2EndView {}
5465#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5466pub struct LitStr2ListHandle(pub(crate) super::tree::CstNodeId);
5467impl NonTerminalHandle for LitStr2ListHandle {
5468 type View = Option<LitStr2ListView>;
5469 fn node_id(&self) -> CstNodeId {
5470 self.0
5471 }
5472 fn new_with_visit<F: CstFacade, E>(
5473 index: CstNodeId,
5474 tree: &F,
5475 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5476 ) -> Result<Self, CstConstructError<E>> {
5477 tree.collect_nodes(
5478 index,
5479 [NodeKind::NonTerminal(NonTerminalKind::LitStr2List)],
5480 |[index], visit| Ok((Self(index), visit)),
5481 visit_ignored,
5482 )
5483 }
5484 fn kind(&self) -> NonTerminalKind {
5485 NonTerminalKind::LitStr2List
5486 }
5487 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5488 &self,
5489 tree: &F,
5490 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5491 visit_ignored: &'v mut V,
5492 ) -> Result<O, CstConstructError<E>> {
5493 if tree.has_no_children(self.0) {
5494 return Ok(visit(None, visit_ignored).0);
5495 }
5496 tree.collect_nodes(
5497 self.0,
5498 [
5499 NodeKind::NonTerminal(NonTerminalKind::LitStr2ListGroup),
5500 NodeKind::NonTerminal(NonTerminalKind::LitStr2List),
5501 ],
5502 |[lit_str_2_list_group, lit_str_2_list], visit_ignored| {
5503 Ok(visit(
5504 Some(LitStr2ListView {
5505 lit_str_2_list_group: LitStr2ListGroupHandle(lit_str_2_list_group),
5506 lit_str_2_list: LitStr2ListHandle(lit_str_2_list),
5507 }),
5508 visit_ignored,
5509 ))
5510 },
5511 visit_ignored,
5512 )
5513 }
5514}
5515#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5516pub struct LitStr2ListView {
5517 pub lit_str_2_list_group: LitStr2ListGroupHandle,
5518 pub lit_str_2_list: LitStr2ListHandle,
5519}
5520impl<F: CstFacade> RecursiveView<F> for LitStr2ListView {
5521 type Item = LitStr2ListGroupHandle;
5522 fn get_all_with_visit<E>(
5523 &self,
5524 tree: &F,
5525 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5526 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5527 let mut items = Vec::new();
5528 let mut current_view = Some(*self);
5529 while let Some(item) = current_view {
5530 let Self {
5531 lit_str_2_list_group,
5532 ..
5533 } = item;
5534 items.push(lit_str_2_list_group);
5535 item.lit_str_2_list.get_view_with_visit(
5536 tree,
5537 |view, visit_ignored| {
5538 current_view = view;
5539 ((), visit_ignored)
5540 },
5541 visit_ignored,
5542 )?;
5543 }
5544 Ok(items)
5545 }
5546}
5547#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5548pub struct LitStr2ListGroupHandle(pub(crate) super::tree::CstNodeId);
5549impl NonTerminalHandle for LitStr2ListGroupHandle {
5550 type View = LitStr2ListGroupView;
5551 fn node_id(&self) -> CstNodeId {
5552 self.0
5553 }
5554 fn new_with_visit<F: CstFacade, E>(
5555 index: CstNodeId,
5556 tree: &F,
5557 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5558 ) -> Result<Self, CstConstructError<E>> {
5559 tree.collect_nodes(
5560 index,
5561 [NodeKind::NonTerminal(NonTerminalKind::LitStr2ListGroup)],
5562 |[index], visit| Ok((Self(index), visit)),
5563 visit_ignored,
5564 )
5565 }
5566 fn kind(&self) -> NonTerminalKind {
5567 NonTerminalKind::LitStr2ListGroup
5568 }
5569 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5570 &self,
5571 tree: &F,
5572 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5573 visit_ignored: &'v mut V,
5574 ) -> Result<O, CstConstructError<E>> {
5575 let mut children = tree.children(self.0);
5576 let Some(child) = children.next() else {
5577 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5578 };
5579 let Some(child_data) = tree.node_data(child) else {
5580 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5581 };
5582 let variant = match child_data.node_kind() {
5583 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5584 LitStr2ListGroupView::NoSQuote(NoSQuoteHandle(child))
5585 }
5586 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5587 LitStr2ListGroupView::SQuote(SQuoteHandle(child))
5588 }
5589 _ => {
5590 return Err(ViewConstructionError::UnexpectedNode {
5591 node: child,
5592 data: child_data,
5593 expected_kind: child_data.node_kind(),
5594 });
5595 }
5596 };
5597 let (result, _visit) = visit(variant, visit_ignored);
5598 if let Some(extra_child) = children.next() {
5599 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5600 }
5601 Ok(result)
5602 }
5603}
5604#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5605pub enum LitStr2ListGroupView {
5606 NoSQuote(NoSQuoteHandle),
5607 SQuote(SQuoteHandle),
5608}
5609impl LitStr2ListGroupView {}
5610#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5611pub struct LitStr2StartHandle(pub(crate) super::tree::CstNodeId);
5612impl NonTerminalHandle for LitStr2StartHandle {
5613 type View = LitStr2StartView;
5614 fn node_id(&self) -> CstNodeId {
5615 self.0
5616 }
5617 fn new_with_visit<F: CstFacade, E>(
5618 index: CstNodeId,
5619 tree: &F,
5620 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5621 ) -> Result<Self, CstConstructError<E>> {
5622 tree.collect_nodes(
5623 index,
5624 [NodeKind::NonTerminal(NonTerminalKind::LitStr2Start)],
5625 |[index], visit| Ok((Self(index), visit)),
5626 visit_ignored,
5627 )
5628 }
5629 fn kind(&self) -> NonTerminalKind {
5630 NonTerminalKind::LitStr2Start
5631 }
5632 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5633 &self,
5634 tree: &F,
5635 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5636 visit_ignored: &'v mut V,
5637 ) -> Result<O, CstConstructError<E>> {
5638 tree.collect_nodes(
5639 self.0,
5640 [NodeKind::Terminal(TerminalKind::LitStr2Start)],
5641 |[lit_str_2_start], visit_ignored| {
5642 Ok(visit(
5643 LitStr2StartView {
5644 lit_str_2_start: LitStr2Start(lit_str_2_start),
5645 },
5646 visit_ignored,
5647 ))
5648 },
5649 visit_ignored,
5650 )
5651 }
5652}
5653#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5654pub struct LitStr2StartView {
5655 pub lit_str_2_start: LitStr2Start,
5656}
5657impl LitStr2StartView {}
5658#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5659pub struct LitStr3Handle(pub(crate) super::tree::CstNodeId);
5660impl NonTerminalHandle for LitStr3Handle {
5661 type View = LitStr3View;
5662 fn node_id(&self) -> CstNodeId {
5663 self.0
5664 }
5665 fn new_with_visit<F: CstFacade, E>(
5666 index: CstNodeId,
5667 tree: &F,
5668 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5669 ) -> Result<Self, CstConstructError<E>> {
5670 tree.collect_nodes(
5671 index,
5672 [NodeKind::NonTerminal(NonTerminalKind::LitStr3)],
5673 |[index], visit| Ok((Self(index), visit)),
5674 visit_ignored,
5675 )
5676 }
5677 fn kind(&self) -> NonTerminalKind {
5678 NonTerminalKind::LitStr3
5679 }
5680 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5681 &self,
5682 tree: &F,
5683 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5684 visit_ignored: &'v mut V,
5685 ) -> Result<O, CstConstructError<E>> {
5686 tree.collect_nodes(
5687 self.0,
5688 [
5689 NodeKind::NonTerminal(NonTerminalKind::LitStr3Start),
5690 NodeKind::NonTerminal(NonTerminalKind::LitStr3List),
5691 NodeKind::NonTerminal(NonTerminalKind::LitStr3End),
5692 ],
5693 |[lit_str_3_start, lit_str_3_list, lit_str_3_end], visit_ignored| {
5694 Ok(visit(
5695 LitStr3View {
5696 lit_str_3_start: LitStr3StartHandle(lit_str_3_start),
5697 lit_str_3_list: LitStr3ListHandle(lit_str_3_list),
5698 lit_str_3_end: LitStr3EndHandle(lit_str_3_end),
5699 },
5700 visit_ignored,
5701 ))
5702 },
5703 visit_ignored,
5704 )
5705 }
5706}
5707#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5708pub struct LitStr3View {
5709 pub lit_str_3_start: LitStr3StartHandle,
5710 pub lit_str_3_list: LitStr3ListHandle,
5711 pub lit_str_3_end: LitStr3EndHandle,
5712}
5713impl LitStr3View {}
5714#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5715pub struct LitStr3EndHandle(pub(crate) super::tree::CstNodeId);
5716impl NonTerminalHandle for LitStr3EndHandle {
5717 type View = LitStr3EndView;
5718 fn node_id(&self) -> CstNodeId {
5719 self.0
5720 }
5721 fn new_with_visit<F: CstFacade, E>(
5722 index: CstNodeId,
5723 tree: &F,
5724 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5725 ) -> Result<Self, CstConstructError<E>> {
5726 tree.collect_nodes(
5727 index,
5728 [NodeKind::NonTerminal(NonTerminalKind::LitStr3End)],
5729 |[index], visit| Ok((Self(index), visit)),
5730 visit_ignored,
5731 )
5732 }
5733 fn kind(&self) -> NonTerminalKind {
5734 NonTerminalKind::LitStr3End
5735 }
5736 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5737 &self,
5738 tree: &F,
5739 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5740 visit_ignored: &'v mut V,
5741 ) -> Result<O, CstConstructError<E>> {
5742 tree.collect_nodes(
5743 self.0,
5744 [NodeKind::Terminal(TerminalKind::LitStr3End)],
5745 |[lit_str_3_end], visit_ignored| {
5746 Ok(visit(
5747 LitStr3EndView {
5748 lit_str_3_end: LitStr3End(lit_str_3_end),
5749 },
5750 visit_ignored,
5751 ))
5752 },
5753 visit_ignored,
5754 )
5755 }
5756}
5757#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5758pub struct LitStr3EndView {
5759 pub lit_str_3_end: LitStr3End,
5760}
5761impl LitStr3EndView {}
5762#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5763pub struct LitStr3ListHandle(pub(crate) super::tree::CstNodeId);
5764impl NonTerminalHandle for LitStr3ListHandle {
5765 type View = Option<LitStr3ListView>;
5766 fn node_id(&self) -> CstNodeId {
5767 self.0
5768 }
5769 fn new_with_visit<F: CstFacade, E>(
5770 index: CstNodeId,
5771 tree: &F,
5772 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5773 ) -> Result<Self, CstConstructError<E>> {
5774 tree.collect_nodes(
5775 index,
5776 [NodeKind::NonTerminal(NonTerminalKind::LitStr3List)],
5777 |[index], visit| Ok((Self(index), visit)),
5778 visit_ignored,
5779 )
5780 }
5781 fn kind(&self) -> NonTerminalKind {
5782 NonTerminalKind::LitStr3List
5783 }
5784 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5785 &self,
5786 tree: &F,
5787 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5788 visit_ignored: &'v mut V,
5789 ) -> Result<O, CstConstructError<E>> {
5790 if tree.has_no_children(self.0) {
5791 return Ok(visit(None, visit_ignored).0);
5792 }
5793 tree.collect_nodes(
5794 self.0,
5795 [
5796 NodeKind::NonTerminal(NonTerminalKind::LitStr3ListGroup),
5797 NodeKind::NonTerminal(NonTerminalKind::LitStr3List),
5798 ],
5799 |[lit_str_3_list_group, lit_str_3_list], visit_ignored| {
5800 Ok(visit(
5801 Some(LitStr3ListView {
5802 lit_str_3_list_group: LitStr3ListGroupHandle(lit_str_3_list_group),
5803 lit_str_3_list: LitStr3ListHandle(lit_str_3_list),
5804 }),
5805 visit_ignored,
5806 ))
5807 },
5808 visit_ignored,
5809 )
5810 }
5811}
5812#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5813pub struct LitStr3ListView {
5814 pub lit_str_3_list_group: LitStr3ListGroupHandle,
5815 pub lit_str_3_list: LitStr3ListHandle,
5816}
5817impl<F: CstFacade> RecursiveView<F> for LitStr3ListView {
5818 type Item = LitStr3ListGroupHandle;
5819 fn get_all_with_visit<E>(
5820 &self,
5821 tree: &F,
5822 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5823 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5824 let mut items = Vec::new();
5825 let mut current_view = Some(*self);
5826 while let Some(item) = current_view {
5827 let Self {
5828 lit_str_3_list_group,
5829 ..
5830 } = item;
5831 items.push(lit_str_3_list_group);
5832 item.lit_str_3_list.get_view_with_visit(
5833 tree,
5834 |view, visit_ignored| {
5835 current_view = view;
5836 ((), visit_ignored)
5837 },
5838 visit_ignored,
5839 )?;
5840 }
5841 Ok(items)
5842 }
5843}
5844#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5845pub struct LitStr3ListGroupHandle(pub(crate) super::tree::CstNodeId);
5846impl NonTerminalHandle for LitStr3ListGroupHandle {
5847 type View = LitStr3ListGroupView;
5848 fn node_id(&self) -> CstNodeId {
5849 self.0
5850 }
5851 fn new_with_visit<F: CstFacade, E>(
5852 index: CstNodeId,
5853 tree: &F,
5854 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5855 ) -> Result<Self, CstConstructError<E>> {
5856 tree.collect_nodes(
5857 index,
5858 [NodeKind::NonTerminal(NonTerminalKind::LitStr3ListGroup)],
5859 |[index], visit| Ok((Self(index), visit)),
5860 visit_ignored,
5861 )
5862 }
5863 fn kind(&self) -> NonTerminalKind {
5864 NonTerminalKind::LitStr3ListGroup
5865 }
5866 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5867 &self,
5868 tree: &F,
5869 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5870 visit_ignored: &'v mut V,
5871 ) -> Result<O, CstConstructError<E>> {
5872 let mut children = tree.children(self.0);
5873 let Some(child) = children.next() else {
5874 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5875 };
5876 let Some(child_data) = tree.node_data(child) else {
5877 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5878 };
5879 let variant = match child_data.node_kind() {
5880 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5881 LitStr3ListGroupView::NoSQuote(NoSQuoteHandle(child))
5882 }
5883 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5884 LitStr3ListGroupView::SQuote(SQuoteHandle(child))
5885 }
5886 _ => {
5887 return Err(ViewConstructionError::UnexpectedNode {
5888 node: child,
5889 data: child_data,
5890 expected_kind: child_data.node_kind(),
5891 });
5892 }
5893 };
5894 let (result, _visit) = visit(variant, visit_ignored);
5895 if let Some(extra_child) = children.next() {
5896 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5897 }
5898 Ok(result)
5899 }
5900}
5901#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5902pub enum LitStr3ListGroupView {
5903 NoSQuote(NoSQuoteHandle),
5904 SQuote(SQuoteHandle),
5905}
5906impl LitStr3ListGroupView {}
5907#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5908pub struct LitStr3StartHandle(pub(crate) super::tree::CstNodeId);
5909impl NonTerminalHandle for LitStr3StartHandle {
5910 type View = LitStr3StartView;
5911 fn node_id(&self) -> CstNodeId {
5912 self.0
5913 }
5914 fn new_with_visit<F: CstFacade, E>(
5915 index: CstNodeId,
5916 tree: &F,
5917 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5918 ) -> Result<Self, CstConstructError<E>> {
5919 tree.collect_nodes(
5920 index,
5921 [NodeKind::NonTerminal(NonTerminalKind::LitStr3Start)],
5922 |[index], visit| Ok((Self(index), visit)),
5923 visit_ignored,
5924 )
5925 }
5926 fn kind(&self) -> NonTerminalKind {
5927 NonTerminalKind::LitStr3Start
5928 }
5929 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5930 &self,
5931 tree: &F,
5932 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5933 visit_ignored: &'v mut V,
5934 ) -> Result<O, CstConstructError<E>> {
5935 tree.collect_nodes(
5936 self.0,
5937 [NodeKind::Terminal(TerminalKind::LitStr3Start)],
5938 |[lit_str_3_start], visit_ignored| {
5939 Ok(visit(
5940 LitStr3StartView {
5941 lit_str_3_start: LitStr3Start(lit_str_3_start),
5942 },
5943 visit_ignored,
5944 ))
5945 },
5946 visit_ignored,
5947 )
5948 }
5949}
5950#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5951pub struct LitStr3StartView {
5952 pub lit_str_3_start: LitStr3Start,
5953}
5954impl LitStr3StartView {}
5955#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5956pub struct MapBindHandle(pub(crate) super::tree::CstNodeId);
5957impl NonTerminalHandle for MapBindHandle {
5958 type View = MapBindView;
5959 fn node_id(&self) -> CstNodeId {
5960 self.0
5961 }
5962 fn new_with_visit<F: CstFacade, E>(
5963 index: CstNodeId,
5964 tree: &F,
5965 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5966 ) -> Result<Self, CstConstructError<E>> {
5967 tree.collect_nodes(
5968 index,
5969 [NodeKind::NonTerminal(NonTerminalKind::MapBind)],
5970 |[index], visit| Ok((Self(index), visit)),
5971 visit_ignored,
5972 )
5973 }
5974 fn kind(&self) -> NonTerminalKind {
5975 NonTerminalKind::MapBind
5976 }
5977 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5978 &self,
5979 tree: &F,
5980 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5981 visit_ignored: &'v mut V,
5982 ) -> Result<O, CstConstructError<E>> {
5983 tree.collect_nodes(
5984 self.0,
5985 [NodeKind::Terminal(TerminalKind::MapBind)],
5986 |[map_bind], visit_ignored| {
5987 Ok(visit(
5988 MapBindView {
5989 map_bind: MapBind(map_bind),
5990 },
5991 visit_ignored,
5992 ))
5993 },
5994 visit_ignored,
5995 )
5996 }
5997}
5998#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5999pub struct MapBindView {
6000 pub map_bind: MapBind,
6001}
6002impl MapBindView {}
6003#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6004pub struct NaNHandle(pub(crate) super::tree::CstNodeId);
6005impl NonTerminalHandle for NaNHandle {
6006 type View = NaNView;
6007 fn node_id(&self) -> CstNodeId {
6008 self.0
6009 }
6010 fn new_with_visit<F: CstFacade, E>(
6011 index: CstNodeId,
6012 tree: &F,
6013 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6014 ) -> Result<Self, CstConstructError<E>> {
6015 tree.collect_nodes(
6016 index,
6017 [NodeKind::NonTerminal(NonTerminalKind::NaN)],
6018 |[index], visit| Ok((Self(index), visit)),
6019 visit_ignored,
6020 )
6021 }
6022 fn kind(&self) -> NonTerminalKind {
6023 NonTerminalKind::NaN
6024 }
6025 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6026 &self,
6027 tree: &F,
6028 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6029 visit_ignored: &'v mut V,
6030 ) -> Result<O, CstConstructError<E>> {
6031 tree.collect_nodes(
6032 self.0,
6033 [NodeKind::Terminal(TerminalKind::NaN)],
6034 |[na_n], visit_ignored| Ok(visit(NaNView { na_n: NaN(na_n) }, visit_ignored)),
6035 visit_ignored,
6036 )
6037 }
6038}
6039#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6040pub struct NaNView {
6041 pub na_n: NaN,
6042}
6043impl NaNView {}
6044#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6045pub struct NoBacktickHandle(pub(crate) super::tree::CstNodeId);
6046impl NonTerminalHandle for NoBacktickHandle {
6047 type View = NoBacktickView;
6048 fn node_id(&self) -> CstNodeId {
6049 self.0
6050 }
6051 fn new_with_visit<F: CstFacade, E>(
6052 index: CstNodeId,
6053 tree: &F,
6054 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6055 ) -> Result<Self, CstConstructError<E>> {
6056 tree.collect_nodes(
6057 index,
6058 [NodeKind::NonTerminal(NonTerminalKind::NoBacktick)],
6059 |[index], visit| Ok((Self(index), visit)),
6060 visit_ignored,
6061 )
6062 }
6063 fn kind(&self) -> NonTerminalKind {
6064 NonTerminalKind::NoBacktick
6065 }
6066 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6067 &self,
6068 tree: &F,
6069 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6070 visit_ignored: &'v mut V,
6071 ) -> Result<O, CstConstructError<E>> {
6072 tree.collect_nodes(
6073 self.0,
6074 [NodeKind::Terminal(TerminalKind::NoBacktick)],
6075 |[no_backtick], visit_ignored| {
6076 Ok(visit(
6077 NoBacktickView {
6078 no_backtick: NoBacktick(no_backtick),
6079 },
6080 visit_ignored,
6081 ))
6082 },
6083 visit_ignored,
6084 )
6085 }
6086}
6087#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6088pub struct NoBacktickView {
6089 pub no_backtick: NoBacktick,
6090}
6091impl NoBacktickView {}
6092#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6093pub struct NoSQuoteHandle(pub(crate) super::tree::CstNodeId);
6094impl NonTerminalHandle for NoSQuoteHandle {
6095 type View = NoSQuoteView;
6096 fn node_id(&self) -> CstNodeId {
6097 self.0
6098 }
6099 fn new_with_visit<F: CstFacade, E>(
6100 index: CstNodeId,
6101 tree: &F,
6102 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6103 ) -> Result<Self, CstConstructError<E>> {
6104 tree.collect_nodes(
6105 index,
6106 [NodeKind::NonTerminal(NonTerminalKind::NoSQuote)],
6107 |[index], visit| Ok((Self(index), visit)),
6108 visit_ignored,
6109 )
6110 }
6111 fn kind(&self) -> NonTerminalKind {
6112 NonTerminalKind::NoSQuote
6113 }
6114 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6115 &self,
6116 tree: &F,
6117 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6118 visit_ignored: &'v mut V,
6119 ) -> Result<O, CstConstructError<E>> {
6120 tree.collect_nodes(
6121 self.0,
6122 [NodeKind::Terminal(TerminalKind::NoSQuote)],
6123 |[no_s_quote], visit_ignored| {
6124 Ok(visit(
6125 NoSQuoteView {
6126 no_s_quote: NoSQuote(no_s_quote),
6127 },
6128 visit_ignored,
6129 ))
6130 },
6131 visit_ignored,
6132 )
6133 }
6134}
6135#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6136pub struct NoSQuoteView {
6137 pub no_s_quote: NoSQuote,
6138}
6139impl NoSQuoteView {}
6140#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6141pub struct NullHandle(pub(crate) super::tree::CstNodeId);
6142impl NonTerminalHandle for NullHandle {
6143 type View = NullView;
6144 fn node_id(&self) -> CstNodeId {
6145 self.0
6146 }
6147 fn new_with_visit<F: CstFacade, E>(
6148 index: CstNodeId,
6149 tree: &F,
6150 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6151 ) -> Result<Self, CstConstructError<E>> {
6152 tree.collect_nodes(
6153 index,
6154 [NodeKind::NonTerminal(NonTerminalKind::Null)],
6155 |[index], visit| Ok((Self(index), visit)),
6156 visit_ignored,
6157 )
6158 }
6159 fn kind(&self) -> NonTerminalKind {
6160 NonTerminalKind::Null
6161 }
6162 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6163 &self,
6164 tree: &F,
6165 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6166 visit_ignored: &'v mut V,
6167 ) -> Result<O, CstConstructError<E>> {
6168 tree.collect_nodes(
6169 self.0,
6170 [NodeKind::Terminal(TerminalKind::Null)],
6171 |[null], visit_ignored| Ok(visit(NullView { null: Null(null) }, visit_ignored)),
6172 visit_ignored,
6173 )
6174 }
6175}
6176#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6177pub struct NullView {
6178 pub null: Null,
6179}
6180impl NullView {}
6181#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6182pub struct NumberHandle(pub(crate) super::tree::CstNodeId);
6183impl NonTerminalHandle for NumberHandle {
6184 type View = NumberView;
6185 fn node_id(&self) -> CstNodeId {
6186 self.0
6187 }
6188 fn new_with_visit<F: CstFacade, E>(
6189 index: CstNodeId,
6190 tree: &F,
6191 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6192 ) -> Result<Self, CstConstructError<E>> {
6193 tree.collect_nodes(
6194 index,
6195 [NodeKind::NonTerminal(NonTerminalKind::Number)],
6196 |[index], visit| Ok((Self(index), visit)),
6197 visit_ignored,
6198 )
6199 }
6200 fn kind(&self) -> NonTerminalKind {
6201 NonTerminalKind::Number
6202 }
6203 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6204 &self,
6205 tree: &F,
6206 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6207 visit_ignored: &'v mut V,
6208 ) -> Result<O, CstConstructError<E>> {
6209 let mut children = tree.children(self.0);
6210 let Some(child) = children.next() else {
6211 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6212 };
6213 let Some(child_data) = tree.node_data(child) else {
6214 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6215 };
6216 let variant = match child_data.node_kind() {
6217 NodeKind::NonTerminal(NonTerminalKind::Float) => NumberView::Float(FloatHandle(child)),
6218 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
6219 NumberView::Integer(IntegerHandle(child))
6220 }
6221 NodeKind::NonTerminal(NonTerminalKind::Inf) => NumberView::Inf(InfHandle(child)),
6222 NodeKind::NonTerminal(NonTerminalKind::NaN) => NumberView::NaN(NaNHandle(child)),
6223 _ => {
6224 return Err(ViewConstructionError::UnexpectedNode {
6225 node: child,
6226 data: child_data,
6227 expected_kind: child_data.node_kind(),
6228 });
6229 }
6230 };
6231 let (result, _visit) = visit(variant, visit_ignored);
6232 if let Some(extra_child) = children.next() {
6233 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6234 }
6235 Ok(result)
6236 }
6237}
6238#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6239pub enum NumberView {
6240 Float(FloatHandle),
6241 Integer(IntegerHandle),
6242 Inf(InfHandle),
6243 NaN(NaNHandle),
6244}
6245impl NumberView {}
6246#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6247pub struct ObjectHandle(pub(crate) super::tree::CstNodeId);
6248impl NonTerminalHandle for ObjectHandle {
6249 type View = ObjectView;
6250 fn node_id(&self) -> CstNodeId {
6251 self.0
6252 }
6253 fn new_with_visit<F: CstFacade, E>(
6254 index: CstNodeId,
6255 tree: &F,
6256 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6257 ) -> Result<Self, CstConstructError<E>> {
6258 tree.collect_nodes(
6259 index,
6260 [NodeKind::NonTerminal(NonTerminalKind::Object)],
6261 |[index], visit| Ok((Self(index), visit)),
6262 visit_ignored,
6263 )
6264 }
6265 fn kind(&self) -> NonTerminalKind {
6266 NonTerminalKind::Object
6267 }
6268 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6269 &self,
6270 tree: &F,
6271 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6272 visit_ignored: &'v mut V,
6273 ) -> Result<O, CstConstructError<E>> {
6274 tree.collect_nodes(
6275 self.0,
6276 [
6277 NodeKind::NonTerminal(NonTerminalKind::Begin),
6278 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt),
6279 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
6280 NodeKind::NonTerminal(NonTerminalKind::End),
6281 ],
6282 |[begin, object_opt, object_list, end], visit_ignored| {
6283 Ok(visit(
6284 ObjectView {
6285 begin: BeginHandle(begin),
6286 object_opt: ObjectOptHandle(object_opt),
6287 object_list: ObjectListHandle(object_list),
6288 end: EndHandle(end),
6289 },
6290 visit_ignored,
6291 ))
6292 },
6293 visit_ignored,
6294 )
6295 }
6296}
6297#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6298pub struct ObjectView {
6299 pub begin: BeginHandle,
6300 pub object_opt: ObjectOptHandle,
6301 pub object_list: ObjectListHandle,
6302 pub end: EndHandle,
6303}
6304impl ObjectView {}
6305#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6306pub struct ObjectListHandle(pub(crate) super::tree::CstNodeId);
6307impl NonTerminalHandle for ObjectListHandle {
6308 type View = Option<ObjectListView>;
6309 fn node_id(&self) -> CstNodeId {
6310 self.0
6311 }
6312 fn new_with_visit<F: CstFacade, E>(
6313 index: CstNodeId,
6314 tree: &F,
6315 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6316 ) -> Result<Self, CstConstructError<E>> {
6317 tree.collect_nodes(
6318 index,
6319 [NodeKind::NonTerminal(NonTerminalKind::ObjectList)],
6320 |[index], visit| Ok((Self(index), visit)),
6321 visit_ignored,
6322 )
6323 }
6324 fn kind(&self) -> NonTerminalKind {
6325 NonTerminalKind::ObjectList
6326 }
6327 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6328 &self,
6329 tree: &F,
6330 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6331 visit_ignored: &'v mut V,
6332 ) -> Result<O, CstConstructError<E>> {
6333 if tree.has_no_children(self.0) {
6334 return Ok(visit(None, visit_ignored).0);
6335 }
6336 tree.collect_nodes(
6337 self.0,
6338 [
6339 NodeKind::NonTerminal(NonTerminalKind::Keys),
6340 NodeKind::NonTerminal(NonTerminalKind::MapBind),
6341 NodeKind::NonTerminal(NonTerminalKind::Value),
6342 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0),
6343 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
6344 ],
6345 |[keys, map_bind, value, object_opt_0, object_list], visit_ignored| {
6346 Ok(visit(
6347 Some(ObjectListView {
6348 keys: KeysHandle(keys),
6349 map_bind: MapBindHandle(map_bind),
6350 value: ValueHandle(value),
6351 object_opt_0: ObjectOpt0Handle(object_opt_0),
6352 object_list: ObjectListHandle(object_list),
6353 }),
6354 visit_ignored,
6355 ))
6356 },
6357 visit_ignored,
6358 )
6359 }
6360}
6361#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6362pub struct ObjectListView {
6363 pub keys: KeysHandle,
6364 pub map_bind: MapBindHandle,
6365 pub value: ValueHandle,
6366 pub object_opt_0: ObjectOpt0Handle,
6367 pub object_list: ObjectListHandle,
6368}
6369impl<F: CstFacade> RecursiveView<F> for ObjectListView {
6370 type Item = ObjectListItem;
6371 fn get_all_with_visit<E>(
6372 &self,
6373 tree: &F,
6374 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6375 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
6376 let mut items = Vec::new();
6377 let mut current_view = Some(*self);
6378 while let Some(item) = current_view {
6379 let Self {
6380 keys,
6381 map_bind,
6382 value,
6383 object_opt_0,
6384 ..
6385 } = item;
6386 items.push(ObjectListItem {
6387 keys,
6388 map_bind,
6389 value,
6390 object_opt_0,
6391 });
6392 item.object_list.get_view_with_visit(
6393 tree,
6394 |view, visit_ignored| {
6395 current_view = view;
6396 ((), visit_ignored)
6397 },
6398 visit_ignored,
6399 )?;
6400 }
6401 Ok(items)
6402 }
6403}
6404#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6405pub struct ObjectListItem {
6406 pub keys: KeysHandle,
6407 pub map_bind: MapBindHandle,
6408 pub value: ValueHandle,
6409 pub object_opt_0: ObjectOpt0Handle,
6410}
6411#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6412pub struct ObjectOptHandle(pub(crate) super::tree::CstNodeId);
6413impl NonTerminalHandle for ObjectOptHandle {
6414 type View = Option<ObjectOptView>;
6415 fn node_id(&self) -> CstNodeId {
6416 self.0
6417 }
6418 fn new_with_visit<F: CstFacade, E>(
6419 index: CstNodeId,
6420 tree: &F,
6421 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6422 ) -> Result<Self, CstConstructError<E>> {
6423 tree.collect_nodes(
6424 index,
6425 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt)],
6426 |[index], visit| Ok((Self(index), visit)),
6427 visit_ignored,
6428 )
6429 }
6430 fn kind(&self) -> NonTerminalKind {
6431 NonTerminalKind::ObjectOpt
6432 }
6433 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6434 &self,
6435 tree: &F,
6436 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6437 visit_ignored: &'v mut V,
6438 ) -> Result<O, CstConstructError<E>> {
6439 if tree.has_no_children(self.0) {
6440 return Ok(visit(None, visit_ignored).0);
6441 }
6442 tree.collect_nodes(
6443 self.0,
6444 [
6445 NodeKind::NonTerminal(NonTerminalKind::ValueBinding),
6446 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1),
6447 ],
6448 |[value_binding, object_opt_1], visit_ignored| {
6449 Ok(visit(
6450 Some(ObjectOptView {
6451 value_binding: ValueBindingHandle(value_binding),
6452 object_opt_1: ObjectOpt1Handle(object_opt_1),
6453 }),
6454 visit_ignored,
6455 ))
6456 },
6457 visit_ignored,
6458 )
6459 }
6460}
6461#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6462pub struct ObjectOptView {
6463 pub value_binding: ValueBindingHandle,
6464 pub object_opt_1: ObjectOpt1Handle,
6465}
6466#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6467pub struct ObjectOpt0Handle(pub(crate) super::tree::CstNodeId);
6468impl NonTerminalHandle for ObjectOpt0Handle {
6469 type View = Option<CommaHandle>;
6470 fn node_id(&self) -> CstNodeId {
6471 self.0
6472 }
6473 fn new_with_visit<F: CstFacade, E>(
6474 index: CstNodeId,
6475 tree: &F,
6476 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6477 ) -> Result<Self, CstConstructError<E>> {
6478 tree.collect_nodes(
6479 index,
6480 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0)],
6481 |[index], visit| Ok((Self(index), visit)),
6482 visit_ignored,
6483 )
6484 }
6485 fn kind(&self) -> NonTerminalKind {
6486 NonTerminalKind::ObjectOpt0
6487 }
6488 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6489 &self,
6490 tree: &F,
6491 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6492 visit_ignored: &'v mut V,
6493 ) -> Result<O, CstConstructError<E>> {
6494 if tree.has_no_children(self.0) {
6495 return Ok(visit(None, visit_ignored).0);
6496 }
6497 Ok(visit(
6498 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
6499 visit_ignored,
6500 )
6501 .0)
6502 }
6503}
6504#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6505pub struct ObjectOpt1Handle(pub(crate) super::tree::CstNodeId);
6506impl NonTerminalHandle for ObjectOpt1Handle {
6507 type View = Option<CommaHandle>;
6508 fn node_id(&self) -> CstNodeId {
6509 self.0
6510 }
6511 fn new_with_visit<F: CstFacade, E>(
6512 index: CstNodeId,
6513 tree: &F,
6514 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6515 ) -> Result<Self, CstConstructError<E>> {
6516 tree.collect_nodes(
6517 index,
6518 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1)],
6519 |[index], visit| Ok((Self(index), visit)),
6520 visit_ignored,
6521 )
6522 }
6523 fn kind(&self) -> NonTerminalKind {
6524 NonTerminalKind::ObjectOpt1
6525 }
6526 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6527 &self,
6528 tree: &F,
6529 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6530 visit_ignored: &'v mut V,
6531 ) -> Result<O, CstConstructError<E>> {
6532 if tree.has_no_children(self.0) {
6533 return Ok(visit(None, visit_ignored).0);
6534 }
6535 Ok(visit(
6536 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
6537 visit_ignored,
6538 )
6539 .0)
6540 }
6541}
6542#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6543pub struct RParenHandle(pub(crate) super::tree::CstNodeId);
6544impl NonTerminalHandle for RParenHandle {
6545 type View = RParenView;
6546 fn node_id(&self) -> CstNodeId {
6547 self.0
6548 }
6549 fn new_with_visit<F: CstFacade, E>(
6550 index: CstNodeId,
6551 tree: &F,
6552 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6553 ) -> Result<Self, CstConstructError<E>> {
6554 tree.collect_nodes(
6555 index,
6556 [NodeKind::NonTerminal(NonTerminalKind::RParen)],
6557 |[index], visit| Ok((Self(index), visit)),
6558 visit_ignored,
6559 )
6560 }
6561 fn kind(&self) -> NonTerminalKind {
6562 NonTerminalKind::RParen
6563 }
6564 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6565 &self,
6566 tree: &F,
6567 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6568 visit_ignored: &'v mut V,
6569 ) -> Result<O, CstConstructError<E>> {
6570 tree.collect_nodes(
6571 self.0,
6572 [NodeKind::Terminal(TerminalKind::RParen)],
6573 |[r_paren], visit_ignored| {
6574 Ok(visit(
6575 RParenView {
6576 r_paren: RParen(r_paren),
6577 },
6578 visit_ignored,
6579 ))
6580 },
6581 visit_ignored,
6582 )
6583 }
6584}
6585#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6586pub struct RParenView {
6587 pub r_paren: RParen,
6588}
6589impl RParenView {}
6590#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6591pub struct RootBindingHandle(pub(crate) super::tree::CstNodeId);
6592impl NonTerminalHandle for RootBindingHandle {
6593 type View = RootBindingView;
6594 fn node_id(&self) -> CstNodeId {
6595 self.0
6596 }
6597 fn new_with_visit<F: CstFacade, E>(
6598 index: CstNodeId,
6599 tree: &F,
6600 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6601 ) -> Result<Self, CstConstructError<E>> {
6602 tree.collect_nodes(
6603 index,
6604 [NodeKind::NonTerminal(NonTerminalKind::RootBinding)],
6605 |[index], visit| Ok((Self(index), visit)),
6606 visit_ignored,
6607 )
6608 }
6609 fn kind(&self) -> NonTerminalKind {
6610 NonTerminalKind::RootBinding
6611 }
6612 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6613 &self,
6614 tree: &F,
6615 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6616 visit_ignored: &'v mut V,
6617 ) -> Result<O, CstConstructError<E>> {
6618 let mut children = tree.children(self.0);
6619 let Some(child) = children.next() else {
6620 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6621 };
6622 let Some(child_data) = tree.node_data(child) else {
6623 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6624 };
6625 let variant = match child_data.node_kind() {
6626 NodeKind::NonTerminal(NonTerminalKind::ValueBinding) => {
6627 RootBindingView::ValueBinding(ValueBindingHandle(child))
6628 }
6629 NodeKind::NonTerminal(NonTerminalKind::TextBinding) => {
6630 RootBindingView::TextBinding(TextBindingHandle(child))
6631 }
6632 _ => {
6633 return Err(ViewConstructionError::UnexpectedNode {
6634 node: child,
6635 data: child_data,
6636 expected_kind: child_data.node_kind(),
6637 });
6638 }
6639 };
6640 let (result, _visit) = visit(variant, visit_ignored);
6641 if let Some(extra_child) = children.next() {
6642 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6643 }
6644 Ok(result)
6645 }
6646}
6647#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6648pub enum RootBindingView {
6649 ValueBinding(ValueBindingHandle),
6650 TextBinding(TextBindingHandle),
6651}
6652impl RootBindingView {}
6653#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6654pub struct SQuoteHandle(pub(crate) super::tree::CstNodeId);
6655impl NonTerminalHandle for SQuoteHandle {
6656 type View = SQuoteView;
6657 fn node_id(&self) -> CstNodeId {
6658 self.0
6659 }
6660 fn new_with_visit<F: CstFacade, E>(
6661 index: CstNodeId,
6662 tree: &F,
6663 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6664 ) -> Result<Self, CstConstructError<E>> {
6665 tree.collect_nodes(
6666 index,
6667 [NodeKind::NonTerminal(NonTerminalKind::SQuote)],
6668 |[index], visit| Ok((Self(index), visit)),
6669 visit_ignored,
6670 )
6671 }
6672 fn kind(&self) -> NonTerminalKind {
6673 NonTerminalKind::SQuote
6674 }
6675 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6676 &self,
6677 tree: &F,
6678 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6679 visit_ignored: &'v mut V,
6680 ) -> Result<O, CstConstructError<E>> {
6681 tree.collect_nodes(
6682 self.0,
6683 [NodeKind::Terminal(TerminalKind::SQuote)],
6684 |[s_quote], visit_ignored| {
6685 Ok(visit(
6686 SQuoteView {
6687 s_quote: SQuote(s_quote),
6688 },
6689 visit_ignored,
6690 ))
6691 },
6692 visit_ignored,
6693 )
6694 }
6695}
6696#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6697pub struct SQuoteView {
6698 pub s_quote: SQuote,
6699}
6700impl SQuoteView {}
6701#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6702pub struct SectionHandle(pub(crate) super::tree::CstNodeId);
6703impl NonTerminalHandle for SectionHandle {
6704 type View = SectionView;
6705 fn node_id(&self) -> CstNodeId {
6706 self.0
6707 }
6708 fn new_with_visit<F: CstFacade, E>(
6709 index: CstNodeId,
6710 tree: &F,
6711 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6712 ) -> Result<Self, CstConstructError<E>> {
6713 tree.collect_nodes(
6714 index,
6715 [NodeKind::NonTerminal(NonTerminalKind::Section)],
6716 |[index], visit| Ok((Self(index), visit)),
6717 visit_ignored,
6718 )
6719 }
6720 fn kind(&self) -> NonTerminalKind {
6721 NonTerminalKind::Section
6722 }
6723 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6724 &self,
6725 tree: &F,
6726 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6727 visit_ignored: &'v mut V,
6728 ) -> Result<O, CstConstructError<E>> {
6729 tree.collect_nodes(
6730 self.0,
6731 [
6732 NodeKind::NonTerminal(NonTerminalKind::At),
6733 NodeKind::NonTerminal(NonTerminalKind::Keys),
6734 NodeKind::NonTerminal(NonTerminalKind::SectionBody),
6735 ],
6736 |[at, keys, section_body], visit_ignored| {
6737 Ok(visit(
6738 SectionView {
6739 at: AtHandle(at),
6740 keys: KeysHandle(keys),
6741 section_body: SectionBodyHandle(section_body),
6742 },
6743 visit_ignored,
6744 ))
6745 },
6746 visit_ignored,
6747 )
6748 }
6749}
6750#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6751pub struct SectionView {
6752 pub at: AtHandle,
6753 pub keys: KeysHandle,
6754 pub section_body: SectionBodyHandle,
6755}
6756impl SectionView {}
6757#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6758pub struct SectionBindingHandle(pub(crate) super::tree::CstNodeId);
6759impl NonTerminalHandle for SectionBindingHandle {
6760 type View = SectionBindingView;
6761 fn node_id(&self) -> CstNodeId {
6762 self.0
6763 }
6764 fn new_with_visit<F: CstFacade, E>(
6765 index: CstNodeId,
6766 tree: &F,
6767 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6768 ) -> Result<Self, CstConstructError<E>> {
6769 tree.collect_nodes(
6770 index,
6771 [NodeKind::NonTerminal(NonTerminalKind::SectionBinding)],
6772 |[index], visit| Ok((Self(index), visit)),
6773 visit_ignored,
6774 )
6775 }
6776 fn kind(&self) -> NonTerminalKind {
6777 NonTerminalKind::SectionBinding
6778 }
6779 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6780 &self,
6781 tree: &F,
6782 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6783 visit_ignored: &'v mut V,
6784 ) -> Result<O, CstConstructError<E>> {
6785 tree.collect_nodes(
6786 self.0,
6787 [
6788 NodeKind::NonTerminal(NonTerminalKind::Begin),
6789 NodeKind::NonTerminal(NonTerminalKind::Eure),
6790 NodeKind::NonTerminal(NonTerminalKind::End),
6791 ],
6792 |[begin, eure, end], visit_ignored| {
6793 Ok(visit(
6794 SectionBindingView {
6795 begin: BeginHandle(begin),
6796 eure: EureHandle(eure),
6797 end: EndHandle(end),
6798 },
6799 visit_ignored,
6800 ))
6801 },
6802 visit_ignored,
6803 )
6804 }
6805}
6806#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6807pub struct SectionBindingView {
6808 pub begin: BeginHandle,
6809 pub eure: EureHandle,
6810 pub end: EndHandle,
6811}
6812impl SectionBindingView {}
6813#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6814pub struct SectionBodyHandle(pub(crate) super::tree::CstNodeId);
6815impl NonTerminalHandle for SectionBodyHandle {
6816 type View = SectionBodyView;
6817 fn node_id(&self) -> CstNodeId {
6818 self.0
6819 }
6820 fn new_with_visit<F: CstFacade, E>(
6821 index: CstNodeId,
6822 tree: &F,
6823 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6824 ) -> Result<Self, CstConstructError<E>> {
6825 tree.collect_nodes(
6826 index,
6827 [NodeKind::NonTerminal(NonTerminalKind::SectionBody)],
6828 |[index], visit| Ok((Self(index), visit)),
6829 visit_ignored,
6830 )
6831 }
6832 fn kind(&self) -> NonTerminalKind {
6833 NonTerminalKind::SectionBody
6834 }
6835 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6836 &self,
6837 tree: &F,
6838 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6839 visit_ignored: &'v mut V,
6840 ) -> Result<O, CstConstructError<E>> {
6841 let mut children = tree.children(self.0);
6842 let Some(child) = children.next() else {
6843 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6844 };
6845 let Some(child_data) = tree.node_data(child) else {
6846 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6847 };
6848 match child_data.node_kind() {
6849 NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt) => tree.collect_nodes(
6850 self.0,
6851 [
6852 NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt),
6853 NodeKind::NonTerminal(NonTerminalKind::SectionBodyList),
6854 ],
6855 |[section_body_opt, section_body_list], visit_ignored| {
6856 Ok(visit(
6857 SectionBodyView::Alt0(SectionBodyAlt0 {
6858 section_body_opt: SectionBodyOptHandle(section_body_opt),
6859 section_body_list: SectionBodyListHandle(section_body_list),
6860 }),
6861 visit_ignored,
6862 ))
6863 },
6864 visit_ignored,
6865 ),
6866 NodeKind::NonTerminal(NonTerminalKind::Begin) => tree.collect_nodes(
6867 self.0,
6868 [
6869 NodeKind::NonTerminal(NonTerminalKind::Begin),
6870 NodeKind::NonTerminal(NonTerminalKind::Eure),
6871 NodeKind::NonTerminal(NonTerminalKind::End),
6872 ],
6873 |[begin, eure, end], visit_ignored| {
6874 Ok(visit(
6875 SectionBodyView::Alt1(SectionBodyAlt1 {
6876 begin: BeginHandle(begin),
6877 eure: EureHandle(eure),
6878 end: EndHandle(end),
6879 }),
6880 visit_ignored,
6881 ))
6882 },
6883 visit_ignored,
6884 ),
6885 _ => Err(ViewConstructionError::UnexpectedNode {
6886 node: child,
6887 data: child_data,
6888 expected_kind: child_data.node_kind(),
6889 }),
6890 }
6891 }
6892}
6893#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6894pub enum SectionBodyView {
6895 Alt0(SectionBodyAlt0),
6896 Alt1(SectionBodyAlt1),
6897}
6898impl SectionBodyView {}
6899#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6900pub struct SectionBodyAlt0 {
6901 pub section_body_opt: SectionBodyOptHandle,
6902 pub section_body_list: SectionBodyListHandle,
6903}
6904#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6905pub struct SectionBodyAlt1 {
6906 pub begin: BeginHandle,
6907 pub eure: EureHandle,
6908 pub end: EndHandle,
6909}
6910#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6911pub struct SectionBodyListHandle(pub(crate) super::tree::CstNodeId);
6912impl NonTerminalHandle for SectionBodyListHandle {
6913 type View = Option<SectionBodyListView>;
6914 fn node_id(&self) -> CstNodeId {
6915 self.0
6916 }
6917 fn new_with_visit<F: CstFacade, E>(
6918 index: CstNodeId,
6919 tree: &F,
6920 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6921 ) -> Result<Self, CstConstructError<E>> {
6922 tree.collect_nodes(
6923 index,
6924 [NodeKind::NonTerminal(NonTerminalKind::SectionBodyList)],
6925 |[index], visit| Ok((Self(index), visit)),
6926 visit_ignored,
6927 )
6928 }
6929 fn kind(&self) -> NonTerminalKind {
6930 NonTerminalKind::SectionBodyList
6931 }
6932 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6933 &self,
6934 tree: &F,
6935 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6936 visit_ignored: &'v mut V,
6937 ) -> Result<O, CstConstructError<E>> {
6938 if tree.has_no_children(self.0) {
6939 return Ok(visit(None, visit_ignored).0);
6940 }
6941 tree.collect_nodes(
6942 self.0,
6943 [
6944 NodeKind::NonTerminal(NonTerminalKind::Binding),
6945 NodeKind::NonTerminal(NonTerminalKind::SectionBodyList),
6946 ],
6947 |[binding, section_body_list], visit_ignored| {
6948 Ok(visit(
6949 Some(SectionBodyListView {
6950 binding: BindingHandle(binding),
6951 section_body_list: SectionBodyListHandle(section_body_list),
6952 }),
6953 visit_ignored,
6954 ))
6955 },
6956 visit_ignored,
6957 )
6958 }
6959}
6960#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6961pub struct SectionBodyListView {
6962 pub binding: BindingHandle,
6963 pub section_body_list: SectionBodyListHandle,
6964}
6965impl<F: CstFacade> RecursiveView<F> for SectionBodyListView {
6966 type Item = BindingHandle;
6967 fn get_all_with_visit<E>(
6968 &self,
6969 tree: &F,
6970 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6971 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
6972 let mut items = Vec::new();
6973 let mut current_view = Some(*self);
6974 while let Some(item) = current_view {
6975 let Self { binding, .. } = item;
6976 items.push(binding);
6977 item.section_body_list.get_view_with_visit(
6978 tree,
6979 |view, visit_ignored| {
6980 current_view = view;
6981 ((), visit_ignored)
6982 },
6983 visit_ignored,
6984 )?;
6985 }
6986 Ok(items)
6987 }
6988}
6989#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6990pub struct SectionBodyOptHandle(pub(crate) super::tree::CstNodeId);
6991impl NonTerminalHandle for SectionBodyOptHandle {
6992 type View = Option<RootBindingHandle>;
6993 fn node_id(&self) -> CstNodeId {
6994 self.0
6995 }
6996 fn new_with_visit<F: CstFacade, E>(
6997 index: CstNodeId,
6998 tree: &F,
6999 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7000 ) -> Result<Self, CstConstructError<E>> {
7001 tree.collect_nodes(
7002 index,
7003 [NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt)],
7004 |[index], visit| Ok((Self(index), visit)),
7005 visit_ignored,
7006 )
7007 }
7008 fn kind(&self) -> NonTerminalKind {
7009 NonTerminalKind::SectionBodyOpt
7010 }
7011 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7012 &self,
7013 tree: &F,
7014 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7015 visit_ignored: &'v mut V,
7016 ) -> Result<O, CstConstructError<E>> {
7017 if tree.has_no_children(self.0) {
7018 return Ok(visit(None, visit_ignored).0);
7019 }
7020 Ok(visit(
7021 Some(RootBindingHandle::new_with_visit(
7022 self.0,
7023 tree,
7024 visit_ignored,
7025 )?),
7026 visit_ignored,
7027 )
7028 .0)
7029 }
7030}
7031#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7032pub struct StrHandle(pub(crate) super::tree::CstNodeId);
7033impl NonTerminalHandle for StrHandle {
7034 type View = StrView;
7035 fn node_id(&self) -> CstNodeId {
7036 self.0
7037 }
7038 fn new_with_visit<F: CstFacade, E>(
7039 index: CstNodeId,
7040 tree: &F,
7041 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7042 ) -> Result<Self, CstConstructError<E>> {
7043 tree.collect_nodes(
7044 index,
7045 [NodeKind::NonTerminal(NonTerminalKind::Str)],
7046 |[index], visit| Ok((Self(index), visit)),
7047 visit_ignored,
7048 )
7049 }
7050 fn kind(&self) -> NonTerminalKind {
7051 NonTerminalKind::Str
7052 }
7053 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7054 &self,
7055 tree: &F,
7056 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7057 visit_ignored: &'v mut V,
7058 ) -> Result<O, CstConstructError<E>> {
7059 tree.collect_nodes(
7060 self.0,
7061 [NodeKind::Terminal(TerminalKind::Str)],
7062 |[str], visit_ignored| Ok(visit(StrView { str: Str(str) }, visit_ignored)),
7063 visit_ignored,
7064 )
7065 }
7066}
7067#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7068pub struct StrView {
7069 pub str: Str,
7070}
7071impl StrView {}
7072#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7073pub struct StringHandle(pub(crate) super::tree::CstNodeId);
7074impl NonTerminalHandle for StringHandle {
7075 type View = StringView;
7076 fn node_id(&self) -> CstNodeId {
7077 self.0
7078 }
7079 fn new_with_visit<F: CstFacade, E>(
7080 index: CstNodeId,
7081 tree: &F,
7082 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7083 ) -> Result<Self, CstConstructError<E>> {
7084 tree.collect_nodes(
7085 index,
7086 [NodeKind::NonTerminal(NonTerminalKind::String)],
7087 |[index], visit| Ok((Self(index), visit)),
7088 visit_ignored,
7089 )
7090 }
7091 fn kind(&self) -> NonTerminalKind {
7092 NonTerminalKind::String
7093 }
7094 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7095 &self,
7096 tree: &F,
7097 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7098 visit_ignored: &'v mut V,
7099 ) -> Result<O, CstConstructError<E>> {
7100 let mut children = tree.children(self.0);
7101 let Some(child) = children.next() else {
7102 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7103 };
7104 let Some(child_data) = tree.node_data(child) else {
7105 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7106 };
7107 let variant = match child_data.node_kind() {
7108 NodeKind::NonTerminal(NonTerminalKind::Str) => StringView::Str(StrHandle(child)),
7109 NodeKind::NonTerminal(NonTerminalKind::LitStr) => {
7110 StringView::LitStr(LitStrHandle(child))
7111 }
7112 NodeKind::NonTerminal(NonTerminalKind::LitStr1) => {
7113 StringView::LitStr1(LitStr1Handle(child))
7114 }
7115 NodeKind::NonTerminal(NonTerminalKind::LitStr2) => {
7116 StringView::LitStr2(LitStr2Handle(child))
7117 }
7118 NodeKind::NonTerminal(NonTerminalKind::LitStr3) => {
7119 StringView::LitStr3(LitStr3Handle(child))
7120 }
7121 _ => {
7122 return Err(ViewConstructionError::UnexpectedNode {
7123 node: child,
7124 data: child_data,
7125 expected_kind: child_data.node_kind(),
7126 });
7127 }
7128 };
7129 let (result, _visit) = visit(variant, visit_ignored);
7130 if let Some(extra_child) = children.next() {
7131 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7132 }
7133 Ok(result)
7134 }
7135}
7136#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7137pub enum StringView {
7138 Str(StrHandle),
7139 LitStr(LitStrHandle),
7140 LitStr1(LitStr1Handle),
7141 LitStr2(LitStr2Handle),
7142 LitStr3(LitStr3Handle),
7143}
7144impl StringView {}
7145#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7146pub struct StringsHandle(pub(crate) super::tree::CstNodeId);
7147impl NonTerminalHandle for StringsHandle {
7148 type View = StringsView;
7149 fn node_id(&self) -> CstNodeId {
7150 self.0
7151 }
7152 fn new_with_visit<F: CstFacade, E>(
7153 index: CstNodeId,
7154 tree: &F,
7155 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7156 ) -> Result<Self, CstConstructError<E>> {
7157 tree.collect_nodes(
7158 index,
7159 [NodeKind::NonTerminal(NonTerminalKind::Strings)],
7160 |[index], visit| Ok((Self(index), visit)),
7161 visit_ignored,
7162 )
7163 }
7164 fn kind(&self) -> NonTerminalKind {
7165 NonTerminalKind::Strings
7166 }
7167 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7168 &self,
7169 tree: &F,
7170 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7171 visit_ignored: &'v mut V,
7172 ) -> Result<O, CstConstructError<E>> {
7173 tree.collect_nodes(
7174 self.0,
7175 [
7176 NodeKind::NonTerminal(NonTerminalKind::String),
7177 NodeKind::NonTerminal(NonTerminalKind::StringsList),
7178 ],
7179 |[string, strings_list], visit_ignored| {
7180 Ok(visit(
7181 StringsView {
7182 string: StringHandle(string),
7183 strings_list: StringsListHandle(strings_list),
7184 },
7185 visit_ignored,
7186 ))
7187 },
7188 visit_ignored,
7189 )
7190 }
7191}
7192#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7193pub struct StringsView {
7194 pub string: StringHandle,
7195 pub strings_list: StringsListHandle,
7196}
7197impl StringsView {}
7198#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7199pub struct StringsListHandle(pub(crate) super::tree::CstNodeId);
7200impl NonTerminalHandle for StringsListHandle {
7201 type View = Option<StringsListView>;
7202 fn node_id(&self) -> CstNodeId {
7203 self.0
7204 }
7205 fn new_with_visit<F: CstFacade, E>(
7206 index: CstNodeId,
7207 tree: &F,
7208 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7209 ) -> Result<Self, CstConstructError<E>> {
7210 tree.collect_nodes(
7211 index,
7212 [NodeKind::NonTerminal(NonTerminalKind::StringsList)],
7213 |[index], visit| Ok((Self(index), visit)),
7214 visit_ignored,
7215 )
7216 }
7217 fn kind(&self) -> NonTerminalKind {
7218 NonTerminalKind::StringsList
7219 }
7220 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7221 &self,
7222 tree: &F,
7223 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7224 visit_ignored: &'v mut V,
7225 ) -> Result<O, CstConstructError<E>> {
7226 if tree.has_no_children(self.0) {
7227 return Ok(visit(None, visit_ignored).0);
7228 }
7229 tree.collect_nodes(
7230 self.0,
7231 [
7232 NodeKind::NonTerminal(NonTerminalKind::Continue),
7233 NodeKind::NonTerminal(NonTerminalKind::String),
7234 NodeKind::NonTerminal(NonTerminalKind::StringsList),
7235 ],
7236 |[r#continue, string, strings_list], visit_ignored| {
7237 Ok(visit(
7238 Some(StringsListView {
7239 r#continue: ContinueHandle(r#continue),
7240 string: StringHandle(string),
7241 strings_list: StringsListHandle(strings_list),
7242 }),
7243 visit_ignored,
7244 ))
7245 },
7246 visit_ignored,
7247 )
7248 }
7249}
7250#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7251pub struct StringsListView {
7252 pub r#continue: ContinueHandle,
7253 pub string: StringHandle,
7254 pub strings_list: StringsListHandle,
7255}
7256impl<F: CstFacade> RecursiveView<F> for StringsListView {
7257 type Item = StringsListItem;
7258 fn get_all_with_visit<E>(
7259 &self,
7260 tree: &F,
7261 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7262 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
7263 let mut items = Vec::new();
7264 let mut current_view = Some(*self);
7265 while let Some(item) = current_view {
7266 let Self {
7267 r#continue, string, ..
7268 } = item;
7269 items.push(StringsListItem { r#continue, string });
7270 item.strings_list.get_view_with_visit(
7271 tree,
7272 |view, visit_ignored| {
7273 current_view = view;
7274 ((), visit_ignored)
7275 },
7276 visit_ignored,
7277 )?;
7278 }
7279 Ok(items)
7280 }
7281}
7282#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7283pub struct StringsListItem {
7284 pub r#continue: ContinueHandle,
7285 pub string: StringHandle,
7286}
7287#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7288pub struct TextHandle(pub(crate) super::tree::CstNodeId);
7289impl NonTerminalHandle for TextHandle {
7290 type View = TextView;
7291 fn node_id(&self) -> CstNodeId {
7292 self.0
7293 }
7294 fn new_with_visit<F: CstFacade, E>(
7295 index: CstNodeId,
7296 tree: &F,
7297 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7298 ) -> Result<Self, CstConstructError<E>> {
7299 tree.collect_nodes(
7300 index,
7301 [NodeKind::NonTerminal(NonTerminalKind::Text)],
7302 |[index], visit| Ok((Self(index), visit)),
7303 visit_ignored,
7304 )
7305 }
7306 fn kind(&self) -> NonTerminalKind {
7307 NonTerminalKind::Text
7308 }
7309 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7310 &self,
7311 tree: &F,
7312 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7313 visit_ignored: &'v mut V,
7314 ) -> Result<O, CstConstructError<E>> {
7315 tree.collect_nodes(
7316 self.0,
7317 [NodeKind::Terminal(TerminalKind::Text)],
7318 |[text], visit_ignored| Ok(visit(TextView { text: Text(text) }, visit_ignored)),
7319 visit_ignored,
7320 )
7321 }
7322}
7323#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7324pub struct TextView {
7325 pub text: Text,
7326}
7327impl TextView {}
7328#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7329pub struct TextBindingHandle(pub(crate) super::tree::CstNodeId);
7330impl NonTerminalHandle for TextBindingHandle {
7331 type View = TextBindingView;
7332 fn node_id(&self) -> CstNodeId {
7333 self.0
7334 }
7335 fn new_with_visit<F: CstFacade, E>(
7336 index: CstNodeId,
7337 tree: &F,
7338 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7339 ) -> Result<Self, CstConstructError<E>> {
7340 tree.collect_nodes(
7341 index,
7342 [NodeKind::NonTerminal(NonTerminalKind::TextBinding)],
7343 |[index], visit| Ok((Self(index), visit)),
7344 visit_ignored,
7345 )
7346 }
7347 fn kind(&self) -> NonTerminalKind {
7348 NonTerminalKind::TextBinding
7349 }
7350 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7351 &self,
7352 tree: &F,
7353 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7354 visit_ignored: &'v mut V,
7355 ) -> Result<O, CstConstructError<E>> {
7356 tree.collect_nodes(
7357 self.0,
7358 [
7359 NodeKind::NonTerminal(NonTerminalKind::TextStart),
7360 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt),
7361 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0),
7362 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt1),
7363 ],
7364 |[
7365 text_start,
7366 text_binding_opt,
7367 text_binding_opt_0,
7368 text_binding_opt_1,
7369 ],
7370 visit_ignored| {
7371 Ok(visit(
7372 TextBindingView {
7373 text_start: TextStartHandle(text_start),
7374 text_binding_opt: TextBindingOptHandle(text_binding_opt),
7375 text_binding_opt_0: TextBindingOpt0Handle(text_binding_opt_0),
7376 text_binding_opt_1: TextBindingOpt1Handle(text_binding_opt_1),
7377 },
7378 visit_ignored,
7379 ))
7380 },
7381 visit_ignored,
7382 )
7383 }
7384}
7385#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7386pub struct TextBindingView {
7387 pub text_start: TextStartHandle,
7388 pub text_binding_opt: TextBindingOptHandle,
7389 pub text_binding_opt_0: TextBindingOpt0Handle,
7390 pub text_binding_opt_1: TextBindingOpt1Handle,
7391}
7392impl TextBindingView {}
7393#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7394pub struct TextBindingOptHandle(pub(crate) super::tree::CstNodeId);
7395impl NonTerminalHandle for TextBindingOptHandle {
7396 type View = Option<WsHandle>;
7397 fn node_id(&self) -> CstNodeId {
7398 self.0
7399 }
7400 fn new_with_visit<F: CstFacade, E>(
7401 index: CstNodeId,
7402 tree: &F,
7403 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7404 ) -> Result<Self, CstConstructError<E>> {
7405 tree.collect_nodes(
7406 index,
7407 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt)],
7408 |[index], visit| Ok((Self(index), visit)),
7409 visit_ignored,
7410 )
7411 }
7412 fn kind(&self) -> NonTerminalKind {
7413 NonTerminalKind::TextBindingOpt
7414 }
7415 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7416 &self,
7417 tree: &F,
7418 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7419 visit_ignored: &'v mut V,
7420 ) -> Result<O, CstConstructError<E>> {
7421 if tree.has_no_children(self.0) {
7422 return Ok(visit(None, visit_ignored).0);
7423 }
7424 Ok(visit(
7425 Some(WsHandle::new_with_visit(self.0, tree, visit_ignored)?),
7426 visit_ignored,
7427 )
7428 .0)
7429 }
7430}
7431#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7432pub struct TextBindingOpt0Handle(pub(crate) super::tree::CstNodeId);
7433impl NonTerminalHandle for TextBindingOpt0Handle {
7434 type View = Option<TextHandle>;
7435 fn node_id(&self) -> CstNodeId {
7436 self.0
7437 }
7438 fn new_with_visit<F: CstFacade, E>(
7439 index: CstNodeId,
7440 tree: &F,
7441 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7442 ) -> Result<Self, CstConstructError<E>> {
7443 tree.collect_nodes(
7444 index,
7445 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0)],
7446 |[index], visit| Ok((Self(index), visit)),
7447 visit_ignored,
7448 )
7449 }
7450 fn kind(&self) -> NonTerminalKind {
7451 NonTerminalKind::TextBindingOpt0
7452 }
7453 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7454 &self,
7455 tree: &F,
7456 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7457 visit_ignored: &'v mut V,
7458 ) -> Result<O, CstConstructError<E>> {
7459 if tree.has_no_children(self.0) {
7460 return Ok(visit(None, visit_ignored).0);
7461 }
7462 Ok(visit(
7463 Some(TextHandle::new_with_visit(self.0, tree, visit_ignored)?),
7464 visit_ignored,
7465 )
7466 .0)
7467 }
7468}
7469#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7470pub struct TextBindingOpt1Handle(pub(crate) super::tree::CstNodeId);
7471impl NonTerminalHandle for TextBindingOpt1Handle {
7472 type View = Option<GrammarNewlineHandle>;
7473 fn node_id(&self) -> CstNodeId {
7474 self.0
7475 }
7476 fn new_with_visit<F: CstFacade, E>(
7477 index: CstNodeId,
7478 tree: &F,
7479 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7480 ) -> Result<Self, CstConstructError<E>> {
7481 tree.collect_nodes(
7482 index,
7483 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt1)],
7484 |[index], visit| Ok((Self(index), visit)),
7485 visit_ignored,
7486 )
7487 }
7488 fn kind(&self) -> NonTerminalKind {
7489 NonTerminalKind::TextBindingOpt1
7490 }
7491 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7492 &self,
7493 tree: &F,
7494 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7495 visit_ignored: &'v mut V,
7496 ) -> Result<O, CstConstructError<E>> {
7497 if tree.has_no_children(self.0) {
7498 return Ok(visit(None, visit_ignored).0);
7499 }
7500 Ok(visit(
7501 Some(GrammarNewlineHandle::new_with_visit(
7502 self.0,
7503 tree,
7504 visit_ignored,
7505 )?),
7506 visit_ignored,
7507 )
7508 .0)
7509 }
7510}
7511#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7512pub struct TextStartHandle(pub(crate) super::tree::CstNodeId);
7513impl NonTerminalHandle for TextStartHandle {
7514 type View = TextStartView;
7515 fn node_id(&self) -> CstNodeId {
7516 self.0
7517 }
7518 fn new_with_visit<F: CstFacade, E>(
7519 index: CstNodeId,
7520 tree: &F,
7521 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7522 ) -> Result<Self, CstConstructError<E>> {
7523 tree.collect_nodes(
7524 index,
7525 [NodeKind::NonTerminal(NonTerminalKind::TextStart)],
7526 |[index], visit| Ok((Self(index), visit)),
7527 visit_ignored,
7528 )
7529 }
7530 fn kind(&self) -> NonTerminalKind {
7531 NonTerminalKind::TextStart
7532 }
7533 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7534 &self,
7535 tree: &F,
7536 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7537 visit_ignored: &'v mut V,
7538 ) -> Result<O, CstConstructError<E>> {
7539 tree.collect_nodes(
7540 self.0,
7541 [NodeKind::Terminal(TerminalKind::TextStart)],
7542 |[text_start], visit_ignored| {
7543 Ok(visit(
7544 TextStartView {
7545 text_start: TextStart(text_start),
7546 },
7547 visit_ignored,
7548 ))
7549 },
7550 visit_ignored,
7551 )
7552 }
7553}
7554#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7555pub struct TextStartView {
7556 pub text_start: TextStart,
7557}
7558impl TextStartView {}
7559#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7560pub struct TrueHandle(pub(crate) super::tree::CstNodeId);
7561impl NonTerminalHandle for TrueHandle {
7562 type View = TrueView;
7563 fn node_id(&self) -> CstNodeId {
7564 self.0
7565 }
7566 fn new_with_visit<F: CstFacade, E>(
7567 index: CstNodeId,
7568 tree: &F,
7569 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7570 ) -> Result<Self, CstConstructError<E>> {
7571 tree.collect_nodes(
7572 index,
7573 [NodeKind::NonTerminal(NonTerminalKind::True)],
7574 |[index], visit| Ok((Self(index), visit)),
7575 visit_ignored,
7576 )
7577 }
7578 fn kind(&self) -> NonTerminalKind {
7579 NonTerminalKind::True
7580 }
7581 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7582 &self,
7583 tree: &F,
7584 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7585 visit_ignored: &'v mut V,
7586 ) -> Result<O, CstConstructError<E>> {
7587 tree.collect_nodes(
7588 self.0,
7589 [NodeKind::Terminal(TerminalKind::True)],
7590 |[r#true], visit_ignored| {
7591 Ok(visit(
7592 TrueView {
7593 r#true: True(r#true),
7594 },
7595 visit_ignored,
7596 ))
7597 },
7598 visit_ignored,
7599 )
7600 }
7601}
7602#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7603pub struct TrueView {
7604 pub r#true: True,
7605}
7606impl TrueView {}
7607#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7608pub struct TupleHandle(pub(crate) super::tree::CstNodeId);
7609impl NonTerminalHandle for TupleHandle {
7610 type View = TupleView;
7611 fn node_id(&self) -> CstNodeId {
7612 self.0
7613 }
7614 fn new_with_visit<F: CstFacade, E>(
7615 index: CstNodeId,
7616 tree: &F,
7617 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7618 ) -> Result<Self, CstConstructError<E>> {
7619 tree.collect_nodes(
7620 index,
7621 [NodeKind::NonTerminal(NonTerminalKind::Tuple)],
7622 |[index], visit| Ok((Self(index), visit)),
7623 visit_ignored,
7624 )
7625 }
7626 fn kind(&self) -> NonTerminalKind {
7627 NonTerminalKind::Tuple
7628 }
7629 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7630 &self,
7631 tree: &F,
7632 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7633 visit_ignored: &'v mut V,
7634 ) -> Result<O, CstConstructError<E>> {
7635 tree.collect_nodes(
7636 self.0,
7637 [
7638 NodeKind::NonTerminal(NonTerminalKind::LParen),
7639 NodeKind::NonTerminal(NonTerminalKind::TupleOpt),
7640 NodeKind::NonTerminal(NonTerminalKind::RParen),
7641 ],
7642 |[l_paren, tuple_opt, r_paren], visit_ignored| {
7643 Ok(visit(
7644 TupleView {
7645 l_paren: LParenHandle(l_paren),
7646 tuple_opt: TupleOptHandle(tuple_opt),
7647 r_paren: RParenHandle(r_paren),
7648 },
7649 visit_ignored,
7650 ))
7651 },
7652 visit_ignored,
7653 )
7654 }
7655}
7656#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7657pub struct TupleView {
7658 pub l_paren: LParenHandle,
7659 pub tuple_opt: TupleOptHandle,
7660 pub r_paren: RParenHandle,
7661}
7662impl TupleView {}
7663#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7664pub struct TupleElementsHandle(pub(crate) super::tree::CstNodeId);
7665impl NonTerminalHandle for TupleElementsHandle {
7666 type View = TupleElementsView;
7667 fn node_id(&self) -> CstNodeId {
7668 self.0
7669 }
7670 fn new_with_visit<F: CstFacade, E>(
7671 index: CstNodeId,
7672 tree: &F,
7673 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7674 ) -> Result<Self, CstConstructError<E>> {
7675 tree.collect_nodes(
7676 index,
7677 [NodeKind::NonTerminal(NonTerminalKind::TupleElements)],
7678 |[index], visit| Ok((Self(index), visit)),
7679 visit_ignored,
7680 )
7681 }
7682 fn kind(&self) -> NonTerminalKind {
7683 NonTerminalKind::TupleElements
7684 }
7685 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7686 &self,
7687 tree: &F,
7688 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7689 visit_ignored: &'v mut V,
7690 ) -> Result<O, CstConstructError<E>> {
7691 tree.collect_nodes(
7692 self.0,
7693 [
7694 NodeKind::NonTerminal(NonTerminalKind::Value),
7695 NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt),
7696 ],
7697 |[value, tuple_elements_opt], visit_ignored| {
7698 Ok(visit(
7699 TupleElementsView {
7700 value: ValueHandle(value),
7701 tuple_elements_opt: TupleElementsOptHandle(tuple_elements_opt),
7702 },
7703 visit_ignored,
7704 ))
7705 },
7706 visit_ignored,
7707 )
7708 }
7709}
7710#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7711pub struct TupleElementsView {
7712 pub value: ValueHandle,
7713 pub tuple_elements_opt: TupleElementsOptHandle,
7714}
7715impl TupleElementsView {}
7716#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7717pub struct TupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
7718impl NonTerminalHandle for TupleElementsOptHandle {
7719 type View = Option<TupleElementsTailHandle>;
7720 fn node_id(&self) -> CstNodeId {
7721 self.0
7722 }
7723 fn new_with_visit<F: CstFacade, E>(
7724 index: CstNodeId,
7725 tree: &F,
7726 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7727 ) -> Result<Self, CstConstructError<E>> {
7728 tree.collect_nodes(
7729 index,
7730 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt)],
7731 |[index], visit| Ok((Self(index), visit)),
7732 visit_ignored,
7733 )
7734 }
7735 fn kind(&self) -> NonTerminalKind {
7736 NonTerminalKind::TupleElementsOpt
7737 }
7738 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7739 &self,
7740 tree: &F,
7741 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7742 visit_ignored: &'v mut V,
7743 ) -> Result<O, CstConstructError<E>> {
7744 if tree.has_no_children(self.0) {
7745 return Ok(visit(None, visit_ignored).0);
7746 }
7747 Ok(visit(
7748 Some(TupleElementsTailHandle::new_with_visit(
7749 self.0,
7750 tree,
7751 visit_ignored,
7752 )?),
7753 visit_ignored,
7754 )
7755 .0)
7756 }
7757}
7758#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7759pub struct TupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
7760impl NonTerminalHandle for TupleElementsTailHandle {
7761 type View = TupleElementsTailView;
7762 fn node_id(&self) -> CstNodeId {
7763 self.0
7764 }
7765 fn new_with_visit<F: CstFacade, E>(
7766 index: CstNodeId,
7767 tree: &F,
7768 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7769 ) -> Result<Self, CstConstructError<E>> {
7770 tree.collect_nodes(
7771 index,
7772 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTail)],
7773 |[index], visit| Ok((Self(index), visit)),
7774 visit_ignored,
7775 )
7776 }
7777 fn kind(&self) -> NonTerminalKind {
7778 NonTerminalKind::TupleElementsTail
7779 }
7780 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7781 &self,
7782 tree: &F,
7783 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7784 visit_ignored: &'v mut V,
7785 ) -> Result<O, CstConstructError<E>> {
7786 tree.collect_nodes(
7787 self.0,
7788 [
7789 NodeKind::NonTerminal(NonTerminalKind::Comma),
7790 NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt),
7791 ],
7792 |[comma, tuple_elements_tail_opt], visit_ignored| {
7793 Ok(visit(
7794 TupleElementsTailView {
7795 comma: CommaHandle(comma),
7796 tuple_elements_tail_opt: TupleElementsTailOptHandle(
7797 tuple_elements_tail_opt,
7798 ),
7799 },
7800 visit_ignored,
7801 ))
7802 },
7803 visit_ignored,
7804 )
7805 }
7806}
7807#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7808pub struct TupleElementsTailView {
7809 pub comma: CommaHandle,
7810 pub tuple_elements_tail_opt: TupleElementsTailOptHandle,
7811}
7812impl TupleElementsTailView {}
7813#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7814pub struct TupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
7815impl NonTerminalHandle for TupleElementsTailOptHandle {
7816 type View = Option<TupleElementsHandle>;
7817 fn node_id(&self) -> CstNodeId {
7818 self.0
7819 }
7820 fn new_with_visit<F: CstFacade, E>(
7821 index: CstNodeId,
7822 tree: &F,
7823 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7824 ) -> Result<Self, CstConstructError<E>> {
7825 tree.collect_nodes(
7826 index,
7827 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt)],
7828 |[index], visit| Ok((Self(index), visit)),
7829 visit_ignored,
7830 )
7831 }
7832 fn kind(&self) -> NonTerminalKind {
7833 NonTerminalKind::TupleElementsTailOpt
7834 }
7835 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7836 &self,
7837 tree: &F,
7838 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7839 visit_ignored: &'v mut V,
7840 ) -> Result<O, CstConstructError<E>> {
7841 if tree.has_no_children(self.0) {
7842 return Ok(visit(None, visit_ignored).0);
7843 }
7844 Ok(visit(
7845 Some(TupleElementsHandle::new_with_visit(
7846 self.0,
7847 tree,
7848 visit_ignored,
7849 )?),
7850 visit_ignored,
7851 )
7852 .0)
7853 }
7854}
7855#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7856pub struct TupleIndexHandle(pub(crate) super::tree::CstNodeId);
7857impl NonTerminalHandle for TupleIndexHandle {
7858 type View = TupleIndexView;
7859 fn node_id(&self) -> CstNodeId {
7860 self.0
7861 }
7862 fn new_with_visit<F: CstFacade, E>(
7863 index: CstNodeId,
7864 tree: &F,
7865 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7866 ) -> Result<Self, CstConstructError<E>> {
7867 tree.collect_nodes(
7868 index,
7869 [NodeKind::NonTerminal(NonTerminalKind::TupleIndex)],
7870 |[index], visit| Ok((Self(index), visit)),
7871 visit_ignored,
7872 )
7873 }
7874 fn kind(&self) -> NonTerminalKind {
7875 NonTerminalKind::TupleIndex
7876 }
7877 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7878 &self,
7879 tree: &F,
7880 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7881 visit_ignored: &'v mut V,
7882 ) -> Result<O, CstConstructError<E>> {
7883 tree.collect_nodes(
7884 self.0,
7885 [
7886 NodeKind::Terminal(TerminalKind::Hash),
7887 NodeKind::NonTerminal(NonTerminalKind::Integer),
7888 ],
7889 |[hash, integer], visit_ignored| {
7890 Ok(visit(
7891 TupleIndexView {
7892 hash: Hash(hash),
7893 integer: IntegerHandle(integer),
7894 },
7895 visit_ignored,
7896 ))
7897 },
7898 visit_ignored,
7899 )
7900 }
7901}
7902#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7903pub struct TupleIndexView {
7904 pub hash: Hash,
7905 pub integer: IntegerHandle,
7906}
7907impl TupleIndexView {}
7908#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7909pub struct TupleOptHandle(pub(crate) super::tree::CstNodeId);
7910impl NonTerminalHandle for TupleOptHandle {
7911 type View = Option<TupleElementsHandle>;
7912 fn node_id(&self) -> CstNodeId {
7913 self.0
7914 }
7915 fn new_with_visit<F: CstFacade, E>(
7916 index: CstNodeId,
7917 tree: &F,
7918 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7919 ) -> Result<Self, CstConstructError<E>> {
7920 tree.collect_nodes(
7921 index,
7922 [NodeKind::NonTerminal(NonTerminalKind::TupleOpt)],
7923 |[index], visit| Ok((Self(index), visit)),
7924 visit_ignored,
7925 )
7926 }
7927 fn kind(&self) -> NonTerminalKind {
7928 NonTerminalKind::TupleOpt
7929 }
7930 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7931 &self,
7932 tree: &F,
7933 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7934 visit_ignored: &'v mut V,
7935 ) -> Result<O, CstConstructError<E>> {
7936 if tree.has_no_children(self.0) {
7937 return Ok(visit(None, visit_ignored).0);
7938 }
7939 Ok(visit(
7940 Some(TupleElementsHandle::new_with_visit(
7941 self.0,
7942 tree,
7943 visit_ignored,
7944 )?),
7945 visit_ignored,
7946 )
7947 .0)
7948 }
7949}
7950#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7951pub struct ValueHandle(pub(crate) super::tree::CstNodeId);
7952impl NonTerminalHandle for ValueHandle {
7953 type View = ValueView;
7954 fn node_id(&self) -> CstNodeId {
7955 self.0
7956 }
7957 fn new_with_visit<F: CstFacade, E>(
7958 index: CstNodeId,
7959 tree: &F,
7960 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7961 ) -> Result<Self, CstConstructError<E>> {
7962 tree.collect_nodes(
7963 index,
7964 [NodeKind::NonTerminal(NonTerminalKind::Value)],
7965 |[index], visit| Ok((Self(index), visit)),
7966 visit_ignored,
7967 )
7968 }
7969 fn kind(&self) -> NonTerminalKind {
7970 NonTerminalKind::Value
7971 }
7972 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7973 &self,
7974 tree: &F,
7975 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7976 visit_ignored: &'v mut V,
7977 ) -> Result<O, CstConstructError<E>> {
7978 let mut children = tree.children(self.0);
7979 let Some(child) = children.next() else {
7980 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7981 };
7982 let Some(child_data) = tree.node_data(child) else {
7983 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7984 };
7985 let variant = match child_data.node_kind() {
7986 NodeKind::NonTerminal(NonTerminalKind::Object) => {
7987 ValueView::Object(ObjectHandle(child))
7988 }
7989 NodeKind::NonTerminal(NonTerminalKind::Array) => ValueView::Array(ArrayHandle(child)),
7990 NodeKind::NonTerminal(NonTerminalKind::Tuple) => ValueView::Tuple(TupleHandle(child)),
7991 NodeKind::NonTerminal(NonTerminalKind::Number) => {
7992 ValueView::Number(NumberHandle(child))
7993 }
7994 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
7995 ValueView::Boolean(BooleanHandle(child))
7996 }
7997 NodeKind::NonTerminal(NonTerminalKind::Null) => ValueView::Null(NullHandle(child)),
7998 NodeKind::NonTerminal(NonTerminalKind::Strings) => {
7999 ValueView::Strings(StringsHandle(child))
8000 }
8001 NodeKind::NonTerminal(NonTerminalKind::Hole) => ValueView::Hole(HoleHandle(child)),
8002 NodeKind::NonTerminal(NonTerminalKind::CodeBlock) => {
8003 ValueView::CodeBlock(CodeBlockHandle(child))
8004 }
8005 NodeKind::NonTerminal(NonTerminalKind::InlineCode) => {
8006 ValueView::InlineCode(InlineCodeHandle(child))
8007 }
8008 _ => {
8009 return Err(ViewConstructionError::UnexpectedNode {
8010 node: child,
8011 data: child_data,
8012 expected_kind: child_data.node_kind(),
8013 });
8014 }
8015 };
8016 let (result, _visit) = visit(variant, visit_ignored);
8017 if let Some(extra_child) = children.next() {
8018 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
8019 }
8020 Ok(result)
8021 }
8022}
8023#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8024pub enum ValueView {
8025 Object(ObjectHandle),
8026 Array(ArrayHandle),
8027 Tuple(TupleHandle),
8028 Number(NumberHandle),
8029 Boolean(BooleanHandle),
8030 Null(NullHandle),
8031 Strings(StringsHandle),
8032 Hole(HoleHandle),
8033 CodeBlock(CodeBlockHandle),
8034 InlineCode(InlineCodeHandle),
8035}
8036impl ValueView {}
8037#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8038pub struct ValueBindingHandle(pub(crate) super::tree::CstNodeId);
8039impl NonTerminalHandle for ValueBindingHandle {
8040 type View = ValueBindingView;
8041 fn node_id(&self) -> CstNodeId {
8042 self.0
8043 }
8044 fn new_with_visit<F: CstFacade, E>(
8045 index: CstNodeId,
8046 tree: &F,
8047 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8048 ) -> Result<Self, CstConstructError<E>> {
8049 tree.collect_nodes(
8050 index,
8051 [NodeKind::NonTerminal(NonTerminalKind::ValueBinding)],
8052 |[index], visit| Ok((Self(index), visit)),
8053 visit_ignored,
8054 )
8055 }
8056 fn kind(&self) -> NonTerminalKind {
8057 NonTerminalKind::ValueBinding
8058 }
8059 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8060 &self,
8061 tree: &F,
8062 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8063 visit_ignored: &'v mut V,
8064 ) -> Result<O, CstConstructError<E>> {
8065 tree.collect_nodes(
8066 self.0,
8067 [
8068 NodeKind::NonTerminal(NonTerminalKind::Bind),
8069 NodeKind::NonTerminal(NonTerminalKind::Value),
8070 ],
8071 |[bind, value], visit_ignored| {
8072 Ok(visit(
8073 ValueBindingView {
8074 bind: BindHandle(bind),
8075 value: ValueHandle(value),
8076 },
8077 visit_ignored,
8078 ))
8079 },
8080 visit_ignored,
8081 )
8082 }
8083}
8084#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8085pub struct ValueBindingView {
8086 pub bind: BindHandle,
8087 pub value: ValueHandle,
8088}
8089impl ValueBindingView {}
8090#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8091pub struct WsHandle(pub(crate) super::tree::CstNodeId);
8092impl NonTerminalHandle for WsHandle {
8093 type View = WsView;
8094 fn node_id(&self) -> CstNodeId {
8095 self.0
8096 }
8097 fn new_with_visit<F: CstFacade, E>(
8098 index: CstNodeId,
8099 tree: &F,
8100 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8101 ) -> Result<Self, CstConstructError<E>> {
8102 tree.collect_nodes(
8103 index,
8104 [NodeKind::NonTerminal(NonTerminalKind::Ws)],
8105 |[index], visit| Ok((Self(index), visit)),
8106 visit_ignored,
8107 )
8108 }
8109 fn kind(&self) -> NonTerminalKind {
8110 NonTerminalKind::Ws
8111 }
8112 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8113 &self,
8114 tree: &F,
8115 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8116 visit_ignored: &'v mut V,
8117 ) -> Result<O, CstConstructError<E>> {
8118 tree.collect_nodes(
8119 self.0,
8120 [NodeKind::Terminal(TerminalKind::Ws)],
8121 |[ws], visit_ignored| Ok(visit(WsView { ws: Ws(ws) }, visit_ignored)),
8122 visit_ignored,
8123 )
8124 }
8125}
8126#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8127pub struct WsView {
8128 pub ws: Ws,
8129}
8130impl WsView {}
8131#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8132pub struct RootHandle(pub(crate) super::tree::CstNodeId);
8133impl NonTerminalHandle for RootHandle {
8134 type View = RootView;
8135 fn node_id(&self) -> CstNodeId {
8136 self.0
8137 }
8138 fn new_with_visit<F: CstFacade, E>(
8139 index: CstNodeId,
8140 tree: &F,
8141 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8142 ) -> Result<Self, CstConstructError<E>> {
8143 tree.collect_nodes(
8144 index,
8145 [NodeKind::NonTerminal(NonTerminalKind::Root)],
8146 |[index], visit| Ok((Self(index), visit)),
8147 visit_ignored,
8148 )
8149 }
8150 fn kind(&self) -> NonTerminalKind {
8151 NonTerminalKind::Root
8152 }
8153 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8154 &self,
8155 tree: &F,
8156 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8157 visit_ignored: &'v mut V,
8158 ) -> Result<O, CstConstructError<E>> {
8159 tree.collect_nodes(
8160 self.0,
8161 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
8162 |[eure], visit_ignored| {
8163 Ok(visit(
8164 RootView {
8165 eure: EureHandle(eure),
8166 },
8167 visit_ignored,
8168 ))
8169 },
8170 visit_ignored,
8171 )
8172 }
8173}
8174#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8175pub struct RootView {
8176 pub eure: EureHandle,
8177}
8178impl RootView {}
8179#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8180pub struct NewLine(pub(crate) super::tree::CstNodeId);
8181impl TerminalHandle for NewLine {
8182 fn node_id(&self) -> CstNodeId {
8183 self.0
8184 }
8185 fn kind(&self) -> TerminalKind {
8186 TerminalKind::NewLine
8187 }
8188}
8189#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8190pub struct Whitespace(pub(crate) super::tree::CstNodeId);
8191impl TerminalHandle for Whitespace {
8192 fn node_id(&self) -> CstNodeId {
8193 self.0
8194 }
8195 fn kind(&self) -> TerminalKind {
8196 TerminalKind::Whitespace
8197 }
8198}
8199#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8200pub struct LineComment(pub(crate) super::tree::CstNodeId);
8201impl TerminalHandle for LineComment {
8202 fn node_id(&self) -> CstNodeId {
8203 self.0
8204 }
8205 fn kind(&self) -> TerminalKind {
8206 TerminalKind::LineComment
8207 }
8208}
8209#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8210pub struct BlockComment(pub(crate) super::tree::CstNodeId);
8211impl TerminalHandle for BlockComment {
8212 fn node_id(&self) -> CstNodeId {
8213 self.0
8214 }
8215 fn kind(&self) -> TerminalKind {
8216 TerminalKind::BlockComment
8217 }
8218}
8219#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8220pub struct Hash(pub(crate) super::tree::CstNodeId);
8221impl TerminalHandle for Hash {
8222 fn node_id(&self) -> CstNodeId {
8223 self.0
8224 }
8225 fn kind(&self) -> TerminalKind {
8226 TerminalKind::Hash
8227 }
8228}
8229#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8230pub struct MapBind(pub(crate) super::tree::CstNodeId);
8231impl TerminalHandle for MapBind {
8232 fn node_id(&self) -> CstNodeId {
8233 self.0
8234 }
8235 fn kind(&self) -> TerminalKind {
8236 TerminalKind::MapBind
8237 }
8238}
8239#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8240pub struct Integer(pub(crate) super::tree::CstNodeId);
8241impl TerminalHandle for Integer {
8242 fn node_id(&self) -> CstNodeId {
8243 self.0
8244 }
8245 fn kind(&self) -> TerminalKind {
8246 TerminalKind::Integer
8247 }
8248}
8249#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8250pub struct Float(pub(crate) super::tree::CstNodeId);
8251impl TerminalHandle for Float {
8252 fn node_id(&self) -> CstNodeId {
8253 self.0
8254 }
8255 fn kind(&self) -> TerminalKind {
8256 TerminalKind::Float
8257 }
8258}
8259#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8260pub struct Inf(pub(crate) super::tree::CstNodeId);
8261impl TerminalHandle for Inf {
8262 fn node_id(&self) -> CstNodeId {
8263 self.0
8264 }
8265 fn kind(&self) -> TerminalKind {
8266 TerminalKind::Inf
8267 }
8268}
8269#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8270pub struct NaN(pub(crate) super::tree::CstNodeId);
8271impl TerminalHandle for NaN {
8272 fn node_id(&self) -> CstNodeId {
8273 self.0
8274 }
8275 fn kind(&self) -> TerminalKind {
8276 TerminalKind::NaN
8277 }
8278}
8279#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8280pub struct True(pub(crate) super::tree::CstNodeId);
8281impl TerminalHandle for True {
8282 fn node_id(&self) -> CstNodeId {
8283 self.0
8284 }
8285 fn kind(&self) -> TerminalKind {
8286 TerminalKind::True
8287 }
8288}
8289#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8290pub struct False(pub(crate) super::tree::CstNodeId);
8291impl TerminalHandle for False {
8292 fn node_id(&self) -> CstNodeId {
8293 self.0
8294 }
8295 fn kind(&self) -> TerminalKind {
8296 TerminalKind::False
8297 }
8298}
8299#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8300pub struct Null(pub(crate) super::tree::CstNodeId);
8301impl TerminalHandle for Null {
8302 fn node_id(&self) -> CstNodeId {
8303 self.0
8304 }
8305 fn kind(&self) -> TerminalKind {
8306 TerminalKind::Null
8307 }
8308}
8309#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8310pub struct Hole(pub(crate) super::tree::CstNodeId);
8311impl TerminalHandle for Hole {
8312 fn node_id(&self) -> CstNodeId {
8313 self.0
8314 }
8315 fn kind(&self) -> TerminalKind {
8316 TerminalKind::Hole
8317 }
8318}
8319#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8320pub struct Str(pub(crate) super::tree::CstNodeId);
8321impl TerminalHandle for Str {
8322 fn node_id(&self) -> CstNodeId {
8323 self.0
8324 }
8325 fn kind(&self) -> TerminalKind {
8326 TerminalKind::Str
8327 }
8328}
8329#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8330pub struct LitStr(pub(crate) super::tree::CstNodeId);
8331impl TerminalHandle for LitStr {
8332 fn node_id(&self) -> CstNodeId {
8333 self.0
8334 }
8335 fn kind(&self) -> TerminalKind {
8336 TerminalKind::LitStr
8337 }
8338}
8339#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8340pub struct Text(pub(crate) super::tree::CstNodeId);
8341impl TerminalHandle for Text {
8342 fn node_id(&self) -> CstNodeId {
8343 self.0
8344 }
8345 fn kind(&self) -> TerminalKind {
8346 TerminalKind::Text
8347 }
8348}
8349#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8350pub struct InlineCode1(pub(crate) super::tree::CstNodeId);
8351impl TerminalHandle for InlineCode1 {
8352 fn node_id(&self) -> CstNodeId {
8353 self.0
8354 }
8355 fn kind(&self) -> TerminalKind {
8356 TerminalKind::InlineCode1
8357 }
8358}
8359#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8360pub struct LitStr3Start(pub(crate) super::tree::CstNodeId);
8361impl TerminalHandle for LitStr3Start {
8362 fn node_id(&self) -> CstNodeId {
8363 self.0
8364 }
8365 fn kind(&self) -> TerminalKind {
8366 TerminalKind::LitStr3Start
8367 }
8368}
8369#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8370pub struct LitStr2Start(pub(crate) super::tree::CstNodeId);
8371impl TerminalHandle for LitStr2Start {
8372 fn node_id(&self) -> CstNodeId {
8373 self.0
8374 }
8375 fn kind(&self) -> TerminalKind {
8376 TerminalKind::LitStr2Start
8377 }
8378}
8379#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8380pub struct LitStr1Start(pub(crate) super::tree::CstNodeId);
8381impl TerminalHandle for LitStr1Start {
8382 fn node_id(&self) -> CstNodeId {
8383 self.0
8384 }
8385 fn kind(&self) -> TerminalKind {
8386 TerminalKind::LitStr1Start
8387 }
8388}
8389#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8390pub struct DelimCodeStart3(pub(crate) super::tree::CstNodeId);
8391impl TerminalHandle for DelimCodeStart3 {
8392 fn node_id(&self) -> CstNodeId {
8393 self.0
8394 }
8395 fn kind(&self) -> TerminalKind {
8396 TerminalKind::DelimCodeStart3
8397 }
8398}
8399#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8400pub struct DelimCodeStart2(pub(crate) super::tree::CstNodeId);
8401impl TerminalHandle for DelimCodeStart2 {
8402 fn node_id(&self) -> CstNodeId {
8403 self.0
8404 }
8405 fn kind(&self) -> TerminalKind {
8406 TerminalKind::DelimCodeStart2
8407 }
8408}
8409#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8410pub struct DelimCodeStart1(pub(crate) super::tree::CstNodeId);
8411impl TerminalHandle for DelimCodeStart1 {
8412 fn node_id(&self) -> CstNodeId {
8413 self.0
8414 }
8415 fn kind(&self) -> TerminalKind {
8416 TerminalKind::DelimCodeStart1
8417 }
8418}
8419#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8420pub struct CodeBlockStart3(pub(crate) super::tree::CstNodeId);
8421impl TerminalHandle for CodeBlockStart3 {
8422 fn node_id(&self) -> CstNodeId {
8423 self.0
8424 }
8425 fn kind(&self) -> TerminalKind {
8426 TerminalKind::CodeBlockStart3
8427 }
8428}
8429#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8430pub struct CodeBlockStart4(pub(crate) super::tree::CstNodeId);
8431impl TerminalHandle for CodeBlockStart4 {
8432 fn node_id(&self) -> CstNodeId {
8433 self.0
8434 }
8435 fn kind(&self) -> TerminalKind {
8436 TerminalKind::CodeBlockStart4
8437 }
8438}
8439#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8440pub struct CodeBlockStart5(pub(crate) super::tree::CstNodeId);
8441impl TerminalHandle for CodeBlockStart5 {
8442 fn node_id(&self) -> CstNodeId {
8443 self.0
8444 }
8445 fn kind(&self) -> TerminalKind {
8446 TerminalKind::CodeBlockStart5
8447 }
8448}
8449#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8450pub struct CodeBlockStart6(pub(crate) super::tree::CstNodeId);
8451impl TerminalHandle for CodeBlockStart6 {
8452 fn node_id(&self) -> CstNodeId {
8453 self.0
8454 }
8455 fn kind(&self) -> TerminalKind {
8456 TerminalKind::CodeBlockStart6
8457 }
8458}
8459#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8460pub struct CodeBlockEnd3(pub(crate) super::tree::CstNodeId);
8461impl TerminalHandle for CodeBlockEnd3 {
8462 fn node_id(&self) -> CstNodeId {
8463 self.0
8464 }
8465 fn kind(&self) -> TerminalKind {
8466 TerminalKind::CodeBlockEnd3
8467 }
8468}
8469#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8470pub struct Backtick2(pub(crate) super::tree::CstNodeId);
8471impl TerminalHandle for Backtick2 {
8472 fn node_id(&self) -> CstNodeId {
8473 self.0
8474 }
8475 fn kind(&self) -> TerminalKind {
8476 TerminalKind::Backtick2
8477 }
8478}
8479#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8480pub struct CodeBlockEnd4(pub(crate) super::tree::CstNodeId);
8481impl TerminalHandle for CodeBlockEnd4 {
8482 fn node_id(&self) -> CstNodeId {
8483 self.0
8484 }
8485 fn kind(&self) -> TerminalKind {
8486 TerminalKind::CodeBlockEnd4
8487 }
8488}
8489#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8490pub struct Backtick3(pub(crate) super::tree::CstNodeId);
8491impl TerminalHandle for Backtick3 {
8492 fn node_id(&self) -> CstNodeId {
8493 self.0
8494 }
8495 fn kind(&self) -> TerminalKind {
8496 TerminalKind::Backtick3
8497 }
8498}
8499#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8500pub struct CodeBlockEnd5(pub(crate) super::tree::CstNodeId);
8501impl TerminalHandle for CodeBlockEnd5 {
8502 fn node_id(&self) -> CstNodeId {
8503 self.0
8504 }
8505 fn kind(&self) -> TerminalKind {
8506 TerminalKind::CodeBlockEnd5
8507 }
8508}
8509#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8510pub struct Backtick4(pub(crate) super::tree::CstNodeId);
8511impl TerminalHandle for Backtick4 {
8512 fn node_id(&self) -> CstNodeId {
8513 self.0
8514 }
8515 fn kind(&self) -> TerminalKind {
8516 TerminalKind::Backtick4
8517 }
8518}
8519#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8520pub struct CodeBlockEnd6(pub(crate) super::tree::CstNodeId);
8521impl TerminalHandle for CodeBlockEnd6 {
8522 fn node_id(&self) -> CstNodeId {
8523 self.0
8524 }
8525 fn kind(&self) -> TerminalKind {
8526 TerminalKind::CodeBlockEnd6
8527 }
8528}
8529#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8530pub struct Backtick5(pub(crate) super::tree::CstNodeId);
8531impl TerminalHandle for Backtick5 {
8532 fn node_id(&self) -> CstNodeId {
8533 self.0
8534 }
8535 fn kind(&self) -> TerminalKind {
8536 TerminalKind::Backtick5
8537 }
8538}
8539#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8540pub struct NoBacktick(pub(crate) super::tree::CstNodeId);
8541impl TerminalHandle for NoBacktick {
8542 fn node_id(&self) -> CstNodeId {
8543 self.0
8544 }
8545 fn kind(&self) -> TerminalKind {
8546 TerminalKind::NoBacktick
8547 }
8548}
8549#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8550pub struct LitStr3End(pub(crate) super::tree::CstNodeId);
8551impl TerminalHandle for LitStr3End {
8552 fn node_id(&self) -> CstNodeId {
8553 self.0
8554 }
8555 fn kind(&self) -> TerminalKind {
8556 TerminalKind::LitStr3End
8557 }
8558}
8559#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8560pub struct LitStr2End(pub(crate) super::tree::CstNodeId);
8561impl TerminalHandle for LitStr2End {
8562 fn node_id(&self) -> CstNodeId {
8563 self.0
8564 }
8565 fn kind(&self) -> TerminalKind {
8566 TerminalKind::LitStr2End
8567 }
8568}
8569#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8570pub struct LitStr1End(pub(crate) super::tree::CstNodeId);
8571impl TerminalHandle for LitStr1End {
8572 fn node_id(&self) -> CstNodeId {
8573 self.0
8574 }
8575 fn kind(&self) -> TerminalKind {
8576 TerminalKind::LitStr1End
8577 }
8578}
8579#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8580pub struct SQuote(pub(crate) super::tree::CstNodeId);
8581impl TerminalHandle for SQuote {
8582 fn node_id(&self) -> CstNodeId {
8583 self.0
8584 }
8585 fn kind(&self) -> TerminalKind {
8586 TerminalKind::SQuote
8587 }
8588}
8589#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8590pub struct NoSQuote(pub(crate) super::tree::CstNodeId);
8591impl TerminalHandle for NoSQuote {
8592 fn node_id(&self) -> CstNodeId {
8593 self.0
8594 }
8595 fn kind(&self) -> TerminalKind {
8596 TerminalKind::NoSQuote
8597 }
8598}
8599#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8600pub struct DelimCodeEnd3(pub(crate) super::tree::CstNodeId);
8601impl TerminalHandle for DelimCodeEnd3 {
8602 fn node_id(&self) -> CstNodeId {
8603 self.0
8604 }
8605 fn kind(&self) -> TerminalKind {
8606 TerminalKind::DelimCodeEnd3
8607 }
8608}
8609#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8610pub struct DelimCodeEnd2(pub(crate) super::tree::CstNodeId);
8611impl TerminalHandle for DelimCodeEnd2 {
8612 fn node_id(&self) -> CstNodeId {
8613 self.0
8614 }
8615 fn kind(&self) -> TerminalKind {
8616 TerminalKind::DelimCodeEnd2
8617 }
8618}
8619#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8620pub struct DelimCodeEnd1(pub(crate) super::tree::CstNodeId);
8621impl TerminalHandle for DelimCodeEnd1 {
8622 fn node_id(&self) -> CstNodeId {
8623 self.0
8624 }
8625 fn kind(&self) -> TerminalKind {
8626 TerminalKind::DelimCodeEnd1
8627 }
8628}
8629#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8630pub struct BacktickDelim(pub(crate) super::tree::CstNodeId);
8631impl TerminalHandle for BacktickDelim {
8632 fn node_id(&self) -> CstNodeId {
8633 self.0
8634 }
8635 fn kind(&self) -> TerminalKind {
8636 TerminalKind::BacktickDelim
8637 }
8638}
8639#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8640pub struct GrammarNewline(pub(crate) super::tree::CstNodeId);
8641impl TerminalHandle for GrammarNewline {
8642 fn node_id(&self) -> CstNodeId {
8643 self.0
8644 }
8645 fn kind(&self) -> TerminalKind {
8646 TerminalKind::GrammarNewline
8647 }
8648}
8649#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8650pub struct Ws(pub(crate) super::tree::CstNodeId);
8651impl TerminalHandle for Ws {
8652 fn node_id(&self) -> CstNodeId {
8653 self.0
8654 }
8655 fn kind(&self) -> TerminalKind {
8656 TerminalKind::Ws
8657 }
8658}
8659#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8660pub struct At(pub(crate) super::tree::CstNodeId);
8661impl TerminalHandle for At {
8662 fn node_id(&self) -> CstNodeId {
8663 self.0
8664 }
8665 fn kind(&self) -> TerminalKind {
8666 TerminalKind::At
8667 }
8668}
8669#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8670pub struct Dollar(pub(crate) super::tree::CstNodeId);
8671impl TerminalHandle for Dollar {
8672 fn node_id(&self) -> CstNodeId {
8673 self.0
8674 }
8675 fn kind(&self) -> TerminalKind {
8676 TerminalKind::Dollar
8677 }
8678}
8679#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8680pub struct Dot(pub(crate) super::tree::CstNodeId);
8681impl TerminalHandle for Dot {
8682 fn node_id(&self) -> CstNodeId {
8683 self.0
8684 }
8685 fn kind(&self) -> TerminalKind {
8686 TerminalKind::Dot
8687 }
8688}
8689#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8690pub struct LBrace(pub(crate) super::tree::CstNodeId);
8691impl TerminalHandle for LBrace {
8692 fn node_id(&self) -> CstNodeId {
8693 self.0
8694 }
8695 fn kind(&self) -> TerminalKind {
8696 TerminalKind::LBrace
8697 }
8698}
8699#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8700pub struct RBrace(pub(crate) super::tree::CstNodeId);
8701impl TerminalHandle for RBrace {
8702 fn node_id(&self) -> CstNodeId {
8703 self.0
8704 }
8705 fn kind(&self) -> TerminalKind {
8706 TerminalKind::RBrace
8707 }
8708}
8709#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8710pub struct LBracket(pub(crate) super::tree::CstNodeId);
8711impl TerminalHandle for LBracket {
8712 fn node_id(&self) -> CstNodeId {
8713 self.0
8714 }
8715 fn kind(&self) -> TerminalKind {
8716 TerminalKind::LBracket
8717 }
8718}
8719#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8720pub struct RBracket(pub(crate) super::tree::CstNodeId);
8721impl TerminalHandle for RBracket {
8722 fn node_id(&self) -> CstNodeId {
8723 self.0
8724 }
8725 fn kind(&self) -> TerminalKind {
8726 TerminalKind::RBracket
8727 }
8728}
8729#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8730pub struct LParen(pub(crate) super::tree::CstNodeId);
8731impl TerminalHandle for LParen {
8732 fn node_id(&self) -> CstNodeId {
8733 self.0
8734 }
8735 fn kind(&self) -> TerminalKind {
8736 TerminalKind::LParen
8737 }
8738}
8739#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8740pub struct RParen(pub(crate) super::tree::CstNodeId);
8741impl TerminalHandle for RParen {
8742 fn node_id(&self) -> CstNodeId {
8743 self.0
8744 }
8745 fn kind(&self) -> TerminalKind {
8746 TerminalKind::RParen
8747 }
8748}
8749#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8750pub struct Bind(pub(crate) super::tree::CstNodeId);
8751impl TerminalHandle for Bind {
8752 fn node_id(&self) -> CstNodeId {
8753 self.0
8754 }
8755 fn kind(&self) -> TerminalKind {
8756 TerminalKind::Bind
8757 }
8758}
8759#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8760pub struct Comma(pub(crate) super::tree::CstNodeId);
8761impl TerminalHandle for Comma {
8762 fn node_id(&self) -> CstNodeId {
8763 self.0
8764 }
8765 fn kind(&self) -> TerminalKind {
8766 TerminalKind::Comma
8767 }
8768}
8769#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8770pub struct Esc(pub(crate) super::tree::CstNodeId);
8771impl TerminalHandle for Esc {
8772 fn node_id(&self) -> CstNodeId {
8773 self.0
8774 }
8775 fn kind(&self) -> TerminalKind {
8776 TerminalKind::Esc
8777 }
8778}
8779#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8780pub struct TextStart(pub(crate) super::tree::CstNodeId);
8781impl TerminalHandle for TextStart {
8782 fn node_id(&self) -> CstNodeId {
8783 self.0
8784 }
8785 fn kind(&self) -> TerminalKind {
8786 TerminalKind::TextStart
8787 }
8788}
8789#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8790pub struct Ident(pub(crate) super::tree::CstNodeId);
8791impl TerminalHandle for Ident {
8792 fn node_id(&self) -> CstNodeId {
8793 self.0
8794 }
8795 fn kind(&self) -> TerminalKind {
8796 TerminalKind::Ident
8797 }
8798}