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 BlockBodyHandle(pub(crate) super::tree::CstNodeId);
982impl NonTerminalHandle for BlockBodyHandle {
983 type View = BlockBodyView;
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::BlockBody)],
995 |[index], visit| Ok((Self(index), visit)),
996 visit_ignored,
997 )
998 }
999 fn kind(&self) -> NonTerminalKind {
1000 NonTerminalKind::BlockBody
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 tree.collect_nodes(
1009 self.0,
1010 [
1011 NodeKind::NonTerminal(NonTerminalKind::Begin),
1012 NodeKind::NonTerminal(NonTerminalKind::Eure),
1013 NodeKind::NonTerminal(NonTerminalKind::End),
1014 ],
1015 |[begin, eure, end], visit_ignored| {
1016 Ok(visit(
1017 BlockBodyView {
1018 begin: BeginHandle(begin),
1019 eure: EureHandle(eure),
1020 end: EndHandle(end),
1021 },
1022 visit_ignored,
1023 ))
1024 },
1025 visit_ignored,
1026 )
1027 }
1028}
1029#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1030pub struct BlockBodyView {
1031 pub begin: BeginHandle,
1032 pub eure: EureHandle,
1033 pub end: EndHandle,
1034}
1035impl BlockBodyView {}
1036#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1037pub struct BooleanHandle(pub(crate) super::tree::CstNodeId);
1038impl NonTerminalHandle for BooleanHandle {
1039 type View = BooleanView;
1040 fn node_id(&self) -> CstNodeId {
1041 self.0
1042 }
1043 fn new_with_visit<F: CstFacade, E>(
1044 index: CstNodeId,
1045 tree: &F,
1046 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1047 ) -> Result<Self, CstConstructError<E>> {
1048 tree.collect_nodes(
1049 index,
1050 [NodeKind::NonTerminal(NonTerminalKind::Boolean)],
1051 |[index], visit| Ok((Self(index), visit)),
1052 visit_ignored,
1053 )
1054 }
1055 fn kind(&self) -> NonTerminalKind {
1056 NonTerminalKind::Boolean
1057 }
1058 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1059 &self,
1060 tree: &F,
1061 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1062 visit_ignored: &'v mut V,
1063 ) -> Result<O, CstConstructError<E>> {
1064 let mut children = tree.children(self.0);
1065 let Some(child) = children.next() else {
1066 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1067 };
1068 let Some(child_data) = tree.node_data(child) else {
1069 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1070 };
1071 let variant = match child_data.node_kind() {
1072 NodeKind::NonTerminal(NonTerminalKind::True) => BooleanView::True(TrueHandle(child)),
1073 NodeKind::NonTerminal(NonTerminalKind::False) => BooleanView::False(FalseHandle(child)),
1074 _ => {
1075 return Err(ViewConstructionError::UnexpectedNode {
1076 node: child,
1077 data: child_data,
1078 expected_kind: child_data.node_kind(),
1079 });
1080 }
1081 };
1082 let (result, _visit) = visit(variant, visit_ignored);
1083 if let Some(extra_child) = children.next() {
1084 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1085 }
1086 Ok(result)
1087 }
1088}
1089#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1090pub enum BooleanView {
1091 True(TrueHandle),
1092 False(FalseHandle),
1093}
1094impl BooleanView {}
1095#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1096pub struct CodeBlockHandle(pub(crate) super::tree::CstNodeId);
1097impl NonTerminalHandle for CodeBlockHandle {
1098 type View = CodeBlockView;
1099 fn node_id(&self) -> CstNodeId {
1100 self.0
1101 }
1102 fn new_with_visit<F: CstFacade, E>(
1103 index: CstNodeId,
1104 tree: &F,
1105 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1106 ) -> Result<Self, CstConstructError<E>> {
1107 tree.collect_nodes(
1108 index,
1109 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock)],
1110 |[index], visit| Ok((Self(index), visit)),
1111 visit_ignored,
1112 )
1113 }
1114 fn kind(&self) -> NonTerminalKind {
1115 NonTerminalKind::CodeBlock
1116 }
1117 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1118 &self,
1119 tree: &F,
1120 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1121 visit_ignored: &'v mut V,
1122 ) -> Result<O, CstConstructError<E>> {
1123 let mut children = tree.children(self.0);
1124 let Some(child) = children.next() else {
1125 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1126 };
1127 let Some(child_data) = tree.node_data(child) else {
1128 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1129 };
1130 let variant = match child_data.node_kind() {
1131 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3) => {
1132 CodeBlockView::CodeBlock3(CodeBlock3Handle(child))
1133 }
1134 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4) => {
1135 CodeBlockView::CodeBlock4(CodeBlock4Handle(child))
1136 }
1137 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5) => {
1138 CodeBlockView::CodeBlock5(CodeBlock5Handle(child))
1139 }
1140 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6) => {
1141 CodeBlockView::CodeBlock6(CodeBlock6Handle(child))
1142 }
1143 _ => {
1144 return Err(ViewConstructionError::UnexpectedNode {
1145 node: child,
1146 data: child_data,
1147 expected_kind: child_data.node_kind(),
1148 });
1149 }
1150 };
1151 let (result, _visit) = visit(variant, visit_ignored);
1152 if let Some(extra_child) = children.next() {
1153 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1154 }
1155 Ok(result)
1156 }
1157}
1158#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1159pub enum CodeBlockView {
1160 CodeBlock3(CodeBlock3Handle),
1161 CodeBlock4(CodeBlock4Handle),
1162 CodeBlock5(CodeBlock5Handle),
1163 CodeBlock6(CodeBlock6Handle),
1164}
1165impl CodeBlockView {}
1166#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1167pub struct CodeBlock3Handle(pub(crate) super::tree::CstNodeId);
1168impl NonTerminalHandle for CodeBlock3Handle {
1169 type View = CodeBlock3View;
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::CodeBlock3)],
1181 |[index], visit| Ok((Self(index), visit)),
1182 visit_ignored,
1183 )
1184 }
1185 fn kind(&self) -> NonTerminalKind {
1186 NonTerminalKind::CodeBlock3
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 tree.collect_nodes(
1195 self.0,
1196 [
1197 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart3),
1198 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3List),
1199 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd3),
1200 ],
1201 |[code_block_start_3, code_block_3_list, code_block_end_3], visit_ignored| {
1202 Ok(visit(
1203 CodeBlock3View {
1204 code_block_start_3: CodeBlockStart3Handle(code_block_start_3),
1205 code_block_3_list: CodeBlock3ListHandle(code_block_3_list),
1206 code_block_end_3: CodeBlockEnd3Handle(code_block_end_3),
1207 },
1208 visit_ignored,
1209 ))
1210 },
1211 visit_ignored,
1212 )
1213 }
1214}
1215#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1216pub struct CodeBlock3View {
1217 pub code_block_start_3: CodeBlockStart3Handle,
1218 pub code_block_3_list: CodeBlock3ListHandle,
1219 pub code_block_end_3: CodeBlockEnd3Handle,
1220}
1221impl CodeBlock3View {}
1222#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1223pub struct CodeBlock3ListHandle(pub(crate) super::tree::CstNodeId);
1224impl NonTerminalHandle for CodeBlock3ListHandle {
1225 type View = Option<CodeBlock3ListView>;
1226 fn node_id(&self) -> CstNodeId {
1227 self.0
1228 }
1229 fn new_with_visit<F: CstFacade, E>(
1230 index: CstNodeId,
1231 tree: &F,
1232 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1233 ) -> Result<Self, CstConstructError<E>> {
1234 tree.collect_nodes(
1235 index,
1236 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock3List)],
1237 |[index], visit| Ok((Self(index), visit)),
1238 visit_ignored,
1239 )
1240 }
1241 fn kind(&self) -> NonTerminalKind {
1242 NonTerminalKind::CodeBlock3List
1243 }
1244 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1245 &self,
1246 tree: &F,
1247 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1248 visit_ignored: &'v mut V,
1249 ) -> Result<O, CstConstructError<E>> {
1250 if tree.has_no_children(self.0) {
1251 return Ok(visit(None, visit_ignored).0);
1252 }
1253 tree.collect_nodes(
1254 self.0,
1255 [
1256 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3ListGroup),
1257 NodeKind::NonTerminal(NonTerminalKind::CodeBlock3List),
1258 ],
1259 |[code_block_3_list_group, code_block_3_list], visit_ignored| {
1260 Ok(visit(
1261 Some(CodeBlock3ListView {
1262 code_block_3_list_group: CodeBlock3ListGroupHandle(code_block_3_list_group),
1263 code_block_3_list: CodeBlock3ListHandle(code_block_3_list),
1264 }),
1265 visit_ignored,
1266 ))
1267 },
1268 visit_ignored,
1269 )
1270 }
1271}
1272#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1273pub struct CodeBlock3ListView {
1274 pub code_block_3_list_group: CodeBlock3ListGroupHandle,
1275 pub code_block_3_list: CodeBlock3ListHandle,
1276}
1277impl<F: CstFacade> RecursiveView<F> for CodeBlock3ListView {
1278 type Item = CodeBlock3ListGroupHandle;
1279 fn get_all_with_visit<E>(
1280 &self,
1281 tree: &F,
1282 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1283 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1284 let mut items = Vec::new();
1285 let mut current_view = Some(*self);
1286 while let Some(item) = current_view {
1287 let Self {
1288 code_block_3_list_group,
1289 ..
1290 } = item;
1291 items.push(code_block_3_list_group);
1292 item.code_block_3_list.get_view_with_visit(
1293 tree,
1294 |view, visit_ignored| {
1295 current_view = view;
1296 ((), visit_ignored)
1297 },
1298 visit_ignored,
1299 )?;
1300 }
1301 Ok(items)
1302 }
1303}
1304#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1305pub struct CodeBlock3ListGroupHandle(pub(crate) super::tree::CstNodeId);
1306impl NonTerminalHandle for CodeBlock3ListGroupHandle {
1307 type View = CodeBlock3ListGroupView;
1308 fn node_id(&self) -> CstNodeId {
1309 self.0
1310 }
1311 fn new_with_visit<F: CstFacade, E>(
1312 index: CstNodeId,
1313 tree: &F,
1314 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1315 ) -> Result<Self, CstConstructError<E>> {
1316 tree.collect_nodes(
1317 index,
1318 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock3ListGroup)],
1319 |[index], visit| Ok((Self(index), visit)),
1320 visit_ignored,
1321 )
1322 }
1323 fn kind(&self) -> NonTerminalKind {
1324 NonTerminalKind::CodeBlock3ListGroup
1325 }
1326 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1327 &self,
1328 tree: &F,
1329 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1330 visit_ignored: &'v mut V,
1331 ) -> Result<O, CstConstructError<E>> {
1332 let mut children = tree.children(self.0);
1333 let Some(child) = children.next() else {
1334 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1335 };
1336 let Some(child_data) = tree.node_data(child) else {
1337 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1338 };
1339 let variant = match child_data.node_kind() {
1340 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1341 CodeBlock3ListGroupView::NoBacktick(NoBacktickHandle(child))
1342 }
1343 NodeKind::NonTerminal(NonTerminalKind::Backtick2) => {
1344 CodeBlock3ListGroupView::Backtick2(Backtick2Handle(child))
1345 }
1346 _ => {
1347 return Err(ViewConstructionError::UnexpectedNode {
1348 node: child,
1349 data: child_data,
1350 expected_kind: child_data.node_kind(),
1351 });
1352 }
1353 };
1354 let (result, _visit) = visit(variant, visit_ignored);
1355 if let Some(extra_child) = children.next() {
1356 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1357 }
1358 Ok(result)
1359 }
1360}
1361#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1362pub enum CodeBlock3ListGroupView {
1363 NoBacktick(NoBacktickHandle),
1364 Backtick2(Backtick2Handle),
1365}
1366impl CodeBlock3ListGroupView {}
1367#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1368pub struct CodeBlock4Handle(pub(crate) super::tree::CstNodeId);
1369impl NonTerminalHandle for CodeBlock4Handle {
1370 type View = CodeBlock4View;
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::CodeBlock4)],
1382 |[index], visit| Ok((Self(index), visit)),
1383 visit_ignored,
1384 )
1385 }
1386 fn kind(&self) -> NonTerminalKind {
1387 NonTerminalKind::CodeBlock4
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 tree.collect_nodes(
1396 self.0,
1397 [
1398 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart4),
1399 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4List),
1400 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd4),
1401 ],
1402 |[code_block_start_4, code_block_4_list, code_block_end_4], visit_ignored| {
1403 Ok(visit(
1404 CodeBlock4View {
1405 code_block_start_4: CodeBlockStart4Handle(code_block_start_4),
1406 code_block_4_list: CodeBlock4ListHandle(code_block_4_list),
1407 code_block_end_4: CodeBlockEnd4Handle(code_block_end_4),
1408 },
1409 visit_ignored,
1410 ))
1411 },
1412 visit_ignored,
1413 )
1414 }
1415}
1416#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1417pub struct CodeBlock4View {
1418 pub code_block_start_4: CodeBlockStart4Handle,
1419 pub code_block_4_list: CodeBlock4ListHandle,
1420 pub code_block_end_4: CodeBlockEnd4Handle,
1421}
1422impl CodeBlock4View {}
1423#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1424pub struct CodeBlock4ListHandle(pub(crate) super::tree::CstNodeId);
1425impl NonTerminalHandle for CodeBlock4ListHandle {
1426 type View = Option<CodeBlock4ListView>;
1427 fn node_id(&self) -> CstNodeId {
1428 self.0
1429 }
1430 fn new_with_visit<F: CstFacade, E>(
1431 index: CstNodeId,
1432 tree: &F,
1433 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1434 ) -> Result<Self, CstConstructError<E>> {
1435 tree.collect_nodes(
1436 index,
1437 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock4List)],
1438 |[index], visit| Ok((Self(index), visit)),
1439 visit_ignored,
1440 )
1441 }
1442 fn kind(&self) -> NonTerminalKind {
1443 NonTerminalKind::CodeBlock4List
1444 }
1445 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1446 &self,
1447 tree: &F,
1448 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1449 visit_ignored: &'v mut V,
1450 ) -> Result<O, CstConstructError<E>> {
1451 if tree.has_no_children(self.0) {
1452 return Ok(visit(None, visit_ignored).0);
1453 }
1454 tree.collect_nodes(
1455 self.0,
1456 [
1457 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4ListGroup),
1458 NodeKind::NonTerminal(NonTerminalKind::CodeBlock4List),
1459 ],
1460 |[code_block_4_list_group, code_block_4_list], visit_ignored| {
1461 Ok(visit(
1462 Some(CodeBlock4ListView {
1463 code_block_4_list_group: CodeBlock4ListGroupHandle(code_block_4_list_group),
1464 code_block_4_list: CodeBlock4ListHandle(code_block_4_list),
1465 }),
1466 visit_ignored,
1467 ))
1468 },
1469 visit_ignored,
1470 )
1471 }
1472}
1473#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1474pub struct CodeBlock4ListView {
1475 pub code_block_4_list_group: CodeBlock4ListGroupHandle,
1476 pub code_block_4_list: CodeBlock4ListHandle,
1477}
1478impl<F: CstFacade> RecursiveView<F> for CodeBlock4ListView {
1479 type Item = CodeBlock4ListGroupHandle;
1480 fn get_all_with_visit<E>(
1481 &self,
1482 tree: &F,
1483 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1484 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1485 let mut items = Vec::new();
1486 let mut current_view = Some(*self);
1487 while let Some(item) = current_view {
1488 let Self {
1489 code_block_4_list_group,
1490 ..
1491 } = item;
1492 items.push(code_block_4_list_group);
1493 item.code_block_4_list.get_view_with_visit(
1494 tree,
1495 |view, visit_ignored| {
1496 current_view = view;
1497 ((), visit_ignored)
1498 },
1499 visit_ignored,
1500 )?;
1501 }
1502 Ok(items)
1503 }
1504}
1505#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1506pub struct CodeBlock4ListGroupHandle(pub(crate) super::tree::CstNodeId);
1507impl NonTerminalHandle for CodeBlock4ListGroupHandle {
1508 type View = CodeBlock4ListGroupView;
1509 fn node_id(&self) -> CstNodeId {
1510 self.0
1511 }
1512 fn new_with_visit<F: CstFacade, E>(
1513 index: CstNodeId,
1514 tree: &F,
1515 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1516 ) -> Result<Self, CstConstructError<E>> {
1517 tree.collect_nodes(
1518 index,
1519 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock4ListGroup)],
1520 |[index], visit| Ok((Self(index), visit)),
1521 visit_ignored,
1522 )
1523 }
1524 fn kind(&self) -> NonTerminalKind {
1525 NonTerminalKind::CodeBlock4ListGroup
1526 }
1527 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1528 &self,
1529 tree: &F,
1530 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1531 visit_ignored: &'v mut V,
1532 ) -> Result<O, CstConstructError<E>> {
1533 let mut children = tree.children(self.0);
1534 let Some(child) = children.next() else {
1535 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1536 };
1537 let Some(child_data) = tree.node_data(child) else {
1538 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1539 };
1540 let variant = match child_data.node_kind() {
1541 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1542 CodeBlock4ListGroupView::NoBacktick(NoBacktickHandle(child))
1543 }
1544 NodeKind::NonTerminal(NonTerminalKind::Backtick3) => {
1545 CodeBlock4ListGroupView::Backtick3(Backtick3Handle(child))
1546 }
1547 _ => {
1548 return Err(ViewConstructionError::UnexpectedNode {
1549 node: child,
1550 data: child_data,
1551 expected_kind: child_data.node_kind(),
1552 });
1553 }
1554 };
1555 let (result, _visit) = visit(variant, visit_ignored);
1556 if let Some(extra_child) = children.next() {
1557 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1558 }
1559 Ok(result)
1560 }
1561}
1562#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1563pub enum CodeBlock4ListGroupView {
1564 NoBacktick(NoBacktickHandle),
1565 Backtick3(Backtick3Handle),
1566}
1567impl CodeBlock4ListGroupView {}
1568#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1569pub struct CodeBlock5Handle(pub(crate) super::tree::CstNodeId);
1570impl NonTerminalHandle for CodeBlock5Handle {
1571 type View = CodeBlock5View;
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::CodeBlock5)],
1583 |[index], visit| Ok((Self(index), visit)),
1584 visit_ignored,
1585 )
1586 }
1587 fn kind(&self) -> NonTerminalKind {
1588 NonTerminalKind::CodeBlock5
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 tree.collect_nodes(
1597 self.0,
1598 [
1599 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart5),
1600 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5List),
1601 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd5),
1602 ],
1603 |[code_block_start_5, code_block_5_list, code_block_end_5], visit_ignored| {
1604 Ok(visit(
1605 CodeBlock5View {
1606 code_block_start_5: CodeBlockStart5Handle(code_block_start_5),
1607 code_block_5_list: CodeBlock5ListHandle(code_block_5_list),
1608 code_block_end_5: CodeBlockEnd5Handle(code_block_end_5),
1609 },
1610 visit_ignored,
1611 ))
1612 },
1613 visit_ignored,
1614 )
1615 }
1616}
1617#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1618pub struct CodeBlock5View {
1619 pub code_block_start_5: CodeBlockStart5Handle,
1620 pub code_block_5_list: CodeBlock5ListHandle,
1621 pub code_block_end_5: CodeBlockEnd5Handle,
1622}
1623impl CodeBlock5View {}
1624#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1625pub struct CodeBlock5ListHandle(pub(crate) super::tree::CstNodeId);
1626impl NonTerminalHandle for CodeBlock5ListHandle {
1627 type View = Option<CodeBlock5ListView>;
1628 fn node_id(&self) -> CstNodeId {
1629 self.0
1630 }
1631 fn new_with_visit<F: CstFacade, E>(
1632 index: CstNodeId,
1633 tree: &F,
1634 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1635 ) -> Result<Self, CstConstructError<E>> {
1636 tree.collect_nodes(
1637 index,
1638 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock5List)],
1639 |[index], visit| Ok((Self(index), visit)),
1640 visit_ignored,
1641 )
1642 }
1643 fn kind(&self) -> NonTerminalKind {
1644 NonTerminalKind::CodeBlock5List
1645 }
1646 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1647 &self,
1648 tree: &F,
1649 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1650 visit_ignored: &'v mut V,
1651 ) -> Result<O, CstConstructError<E>> {
1652 if tree.has_no_children(self.0) {
1653 return Ok(visit(None, visit_ignored).0);
1654 }
1655 tree.collect_nodes(
1656 self.0,
1657 [
1658 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5ListGroup),
1659 NodeKind::NonTerminal(NonTerminalKind::CodeBlock5List),
1660 ],
1661 |[code_block_5_list_group, code_block_5_list], visit_ignored| {
1662 Ok(visit(
1663 Some(CodeBlock5ListView {
1664 code_block_5_list_group: CodeBlock5ListGroupHandle(code_block_5_list_group),
1665 code_block_5_list: CodeBlock5ListHandle(code_block_5_list),
1666 }),
1667 visit_ignored,
1668 ))
1669 },
1670 visit_ignored,
1671 )
1672 }
1673}
1674#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1675pub struct CodeBlock5ListView {
1676 pub code_block_5_list_group: CodeBlock5ListGroupHandle,
1677 pub code_block_5_list: CodeBlock5ListHandle,
1678}
1679impl<F: CstFacade> RecursiveView<F> for CodeBlock5ListView {
1680 type Item = CodeBlock5ListGroupHandle;
1681 fn get_all_with_visit<E>(
1682 &self,
1683 tree: &F,
1684 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1685 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1686 let mut items = Vec::new();
1687 let mut current_view = Some(*self);
1688 while let Some(item) = current_view {
1689 let Self {
1690 code_block_5_list_group,
1691 ..
1692 } = item;
1693 items.push(code_block_5_list_group);
1694 item.code_block_5_list.get_view_with_visit(
1695 tree,
1696 |view, visit_ignored| {
1697 current_view = view;
1698 ((), visit_ignored)
1699 },
1700 visit_ignored,
1701 )?;
1702 }
1703 Ok(items)
1704 }
1705}
1706#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1707pub struct CodeBlock5ListGroupHandle(pub(crate) super::tree::CstNodeId);
1708impl NonTerminalHandle for CodeBlock5ListGroupHandle {
1709 type View = CodeBlock5ListGroupView;
1710 fn node_id(&self) -> CstNodeId {
1711 self.0
1712 }
1713 fn new_with_visit<F: CstFacade, E>(
1714 index: CstNodeId,
1715 tree: &F,
1716 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1717 ) -> Result<Self, CstConstructError<E>> {
1718 tree.collect_nodes(
1719 index,
1720 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock5ListGroup)],
1721 |[index], visit| Ok((Self(index), visit)),
1722 visit_ignored,
1723 )
1724 }
1725 fn kind(&self) -> NonTerminalKind {
1726 NonTerminalKind::CodeBlock5ListGroup
1727 }
1728 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1729 &self,
1730 tree: &F,
1731 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1732 visit_ignored: &'v mut V,
1733 ) -> Result<O, CstConstructError<E>> {
1734 let mut children = tree.children(self.0);
1735 let Some(child) = children.next() else {
1736 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1737 };
1738 let Some(child_data) = tree.node_data(child) else {
1739 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1740 };
1741 let variant = match child_data.node_kind() {
1742 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1743 CodeBlock5ListGroupView::NoBacktick(NoBacktickHandle(child))
1744 }
1745 NodeKind::NonTerminal(NonTerminalKind::Backtick4) => {
1746 CodeBlock5ListGroupView::Backtick4(Backtick4Handle(child))
1747 }
1748 _ => {
1749 return Err(ViewConstructionError::UnexpectedNode {
1750 node: child,
1751 data: child_data,
1752 expected_kind: child_data.node_kind(),
1753 });
1754 }
1755 };
1756 let (result, _visit) = visit(variant, visit_ignored);
1757 if let Some(extra_child) = children.next() {
1758 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1759 }
1760 Ok(result)
1761 }
1762}
1763#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1764pub enum CodeBlock5ListGroupView {
1765 NoBacktick(NoBacktickHandle),
1766 Backtick4(Backtick4Handle),
1767}
1768impl CodeBlock5ListGroupView {}
1769#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1770pub struct CodeBlock6Handle(pub(crate) super::tree::CstNodeId);
1771impl NonTerminalHandle for CodeBlock6Handle {
1772 type View = CodeBlock6View;
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::CodeBlock6)],
1784 |[index], visit| Ok((Self(index), visit)),
1785 visit_ignored,
1786 )
1787 }
1788 fn kind(&self) -> NonTerminalKind {
1789 NonTerminalKind::CodeBlock6
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 tree.collect_nodes(
1798 self.0,
1799 [
1800 NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart6),
1801 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6List),
1802 NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd6),
1803 ],
1804 |[code_block_start_6, code_block_6_list, code_block_end_6], visit_ignored| {
1805 Ok(visit(
1806 CodeBlock6View {
1807 code_block_start_6: CodeBlockStart6Handle(code_block_start_6),
1808 code_block_6_list: CodeBlock6ListHandle(code_block_6_list),
1809 code_block_end_6: CodeBlockEnd6Handle(code_block_end_6),
1810 },
1811 visit_ignored,
1812 ))
1813 },
1814 visit_ignored,
1815 )
1816 }
1817}
1818#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1819pub struct CodeBlock6View {
1820 pub code_block_start_6: CodeBlockStart6Handle,
1821 pub code_block_6_list: CodeBlock6ListHandle,
1822 pub code_block_end_6: CodeBlockEnd6Handle,
1823}
1824impl CodeBlock6View {}
1825#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1826pub struct CodeBlock6ListHandle(pub(crate) super::tree::CstNodeId);
1827impl NonTerminalHandle for CodeBlock6ListHandle {
1828 type View = Option<CodeBlock6ListView>;
1829 fn node_id(&self) -> CstNodeId {
1830 self.0
1831 }
1832 fn new_with_visit<F: CstFacade, E>(
1833 index: CstNodeId,
1834 tree: &F,
1835 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1836 ) -> Result<Self, CstConstructError<E>> {
1837 tree.collect_nodes(
1838 index,
1839 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock6List)],
1840 |[index], visit| Ok((Self(index), visit)),
1841 visit_ignored,
1842 )
1843 }
1844 fn kind(&self) -> NonTerminalKind {
1845 NonTerminalKind::CodeBlock6List
1846 }
1847 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1848 &self,
1849 tree: &F,
1850 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1851 visit_ignored: &'v mut V,
1852 ) -> Result<O, CstConstructError<E>> {
1853 if tree.has_no_children(self.0) {
1854 return Ok(visit(None, visit_ignored).0);
1855 }
1856 tree.collect_nodes(
1857 self.0,
1858 [
1859 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6ListGroup),
1860 NodeKind::NonTerminal(NonTerminalKind::CodeBlock6List),
1861 ],
1862 |[code_block_6_list_group, code_block_6_list], visit_ignored| {
1863 Ok(visit(
1864 Some(CodeBlock6ListView {
1865 code_block_6_list_group: CodeBlock6ListGroupHandle(code_block_6_list_group),
1866 code_block_6_list: CodeBlock6ListHandle(code_block_6_list),
1867 }),
1868 visit_ignored,
1869 ))
1870 },
1871 visit_ignored,
1872 )
1873 }
1874}
1875#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1876pub struct CodeBlock6ListView {
1877 pub code_block_6_list_group: CodeBlock6ListGroupHandle,
1878 pub code_block_6_list: CodeBlock6ListHandle,
1879}
1880impl<F: CstFacade> RecursiveView<F> for CodeBlock6ListView {
1881 type Item = CodeBlock6ListGroupHandle;
1882 fn get_all_with_visit<E>(
1883 &self,
1884 tree: &F,
1885 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1886 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
1887 let mut items = Vec::new();
1888 let mut current_view = Some(*self);
1889 while let Some(item) = current_view {
1890 let Self {
1891 code_block_6_list_group,
1892 ..
1893 } = item;
1894 items.push(code_block_6_list_group);
1895 item.code_block_6_list.get_view_with_visit(
1896 tree,
1897 |view, visit_ignored| {
1898 current_view = view;
1899 ((), visit_ignored)
1900 },
1901 visit_ignored,
1902 )?;
1903 }
1904 Ok(items)
1905 }
1906}
1907#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1908pub struct CodeBlock6ListGroupHandle(pub(crate) super::tree::CstNodeId);
1909impl NonTerminalHandle for CodeBlock6ListGroupHandle {
1910 type View = CodeBlock6ListGroupView;
1911 fn node_id(&self) -> CstNodeId {
1912 self.0
1913 }
1914 fn new_with_visit<F: CstFacade, E>(
1915 index: CstNodeId,
1916 tree: &F,
1917 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1918 ) -> Result<Self, CstConstructError<E>> {
1919 tree.collect_nodes(
1920 index,
1921 [NodeKind::NonTerminal(NonTerminalKind::CodeBlock6ListGroup)],
1922 |[index], visit| Ok((Self(index), visit)),
1923 visit_ignored,
1924 )
1925 }
1926 fn kind(&self) -> NonTerminalKind {
1927 NonTerminalKind::CodeBlock6ListGroup
1928 }
1929 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1930 &self,
1931 tree: &F,
1932 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1933 visit_ignored: &'v mut V,
1934 ) -> Result<O, CstConstructError<E>> {
1935 let mut children = tree.children(self.0);
1936 let Some(child) = children.next() else {
1937 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
1938 };
1939 let Some(child_data) = tree.node_data(child) else {
1940 return Err(ViewConstructionError::NodeIdNotFound { node: child });
1941 };
1942 let variant = match child_data.node_kind() {
1943 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
1944 CodeBlock6ListGroupView::NoBacktick(NoBacktickHandle(child))
1945 }
1946 NodeKind::NonTerminal(NonTerminalKind::Backtick5) => {
1947 CodeBlock6ListGroupView::Backtick5(Backtick5Handle(child))
1948 }
1949 _ => {
1950 return Err(ViewConstructionError::UnexpectedNode {
1951 node: child,
1952 data: child_data,
1953 expected_kind: child_data.node_kind(),
1954 });
1955 }
1956 };
1957 let (result, _visit) = visit(variant, visit_ignored);
1958 if let Some(extra_child) = children.next() {
1959 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
1960 }
1961 Ok(result)
1962 }
1963}
1964#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1965pub enum CodeBlock6ListGroupView {
1966 NoBacktick(NoBacktickHandle),
1967 Backtick5(Backtick5Handle),
1968}
1969impl CodeBlock6ListGroupView {}
1970#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1971pub struct CodeBlockEnd3Handle(pub(crate) super::tree::CstNodeId);
1972impl NonTerminalHandle for CodeBlockEnd3Handle {
1973 type View = CodeBlockEnd3View;
1974 fn node_id(&self) -> CstNodeId {
1975 self.0
1976 }
1977 fn new_with_visit<F: CstFacade, E>(
1978 index: CstNodeId,
1979 tree: &F,
1980 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
1981 ) -> Result<Self, CstConstructError<E>> {
1982 tree.collect_nodes(
1983 index,
1984 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd3)],
1985 |[index], visit| Ok((Self(index), visit)),
1986 visit_ignored,
1987 )
1988 }
1989 fn kind(&self) -> NonTerminalKind {
1990 NonTerminalKind::CodeBlockEnd3
1991 }
1992 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
1993 &self,
1994 tree: &F,
1995 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
1996 visit_ignored: &'v mut V,
1997 ) -> Result<O, CstConstructError<E>> {
1998 tree.collect_nodes(
1999 self.0,
2000 [NodeKind::Terminal(TerminalKind::CodeBlockEnd3)],
2001 |[code_block_end_3], visit_ignored| {
2002 Ok(visit(
2003 CodeBlockEnd3View {
2004 code_block_end_3: CodeBlockEnd3(code_block_end_3),
2005 },
2006 visit_ignored,
2007 ))
2008 },
2009 visit_ignored,
2010 )
2011 }
2012}
2013#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2014pub struct CodeBlockEnd3View {
2015 pub code_block_end_3: CodeBlockEnd3,
2016}
2017impl CodeBlockEnd3View {}
2018#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2019pub struct CodeBlockEnd4Handle(pub(crate) super::tree::CstNodeId);
2020impl NonTerminalHandle for CodeBlockEnd4Handle {
2021 type View = CodeBlockEnd4View;
2022 fn node_id(&self) -> CstNodeId {
2023 self.0
2024 }
2025 fn new_with_visit<F: CstFacade, E>(
2026 index: CstNodeId,
2027 tree: &F,
2028 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2029 ) -> Result<Self, CstConstructError<E>> {
2030 tree.collect_nodes(
2031 index,
2032 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd4)],
2033 |[index], visit| Ok((Self(index), visit)),
2034 visit_ignored,
2035 )
2036 }
2037 fn kind(&self) -> NonTerminalKind {
2038 NonTerminalKind::CodeBlockEnd4
2039 }
2040 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2041 &self,
2042 tree: &F,
2043 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2044 visit_ignored: &'v mut V,
2045 ) -> Result<O, CstConstructError<E>> {
2046 tree.collect_nodes(
2047 self.0,
2048 [NodeKind::Terminal(TerminalKind::CodeBlockEnd4)],
2049 |[code_block_end_4], visit_ignored| {
2050 Ok(visit(
2051 CodeBlockEnd4View {
2052 code_block_end_4: CodeBlockEnd4(code_block_end_4),
2053 },
2054 visit_ignored,
2055 ))
2056 },
2057 visit_ignored,
2058 )
2059 }
2060}
2061#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2062pub struct CodeBlockEnd4View {
2063 pub code_block_end_4: CodeBlockEnd4,
2064}
2065impl CodeBlockEnd4View {}
2066#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2067pub struct CodeBlockEnd5Handle(pub(crate) super::tree::CstNodeId);
2068impl NonTerminalHandle for CodeBlockEnd5Handle {
2069 type View = CodeBlockEnd5View;
2070 fn node_id(&self) -> CstNodeId {
2071 self.0
2072 }
2073 fn new_with_visit<F: CstFacade, E>(
2074 index: CstNodeId,
2075 tree: &F,
2076 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2077 ) -> Result<Self, CstConstructError<E>> {
2078 tree.collect_nodes(
2079 index,
2080 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd5)],
2081 |[index], visit| Ok((Self(index), visit)),
2082 visit_ignored,
2083 )
2084 }
2085 fn kind(&self) -> NonTerminalKind {
2086 NonTerminalKind::CodeBlockEnd5
2087 }
2088 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2089 &self,
2090 tree: &F,
2091 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2092 visit_ignored: &'v mut V,
2093 ) -> Result<O, CstConstructError<E>> {
2094 tree.collect_nodes(
2095 self.0,
2096 [NodeKind::Terminal(TerminalKind::CodeBlockEnd5)],
2097 |[code_block_end_5], visit_ignored| {
2098 Ok(visit(
2099 CodeBlockEnd5View {
2100 code_block_end_5: CodeBlockEnd5(code_block_end_5),
2101 },
2102 visit_ignored,
2103 ))
2104 },
2105 visit_ignored,
2106 )
2107 }
2108}
2109#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2110pub struct CodeBlockEnd5View {
2111 pub code_block_end_5: CodeBlockEnd5,
2112}
2113impl CodeBlockEnd5View {}
2114#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2115pub struct CodeBlockEnd6Handle(pub(crate) super::tree::CstNodeId);
2116impl NonTerminalHandle for CodeBlockEnd6Handle {
2117 type View = CodeBlockEnd6View;
2118 fn node_id(&self) -> CstNodeId {
2119 self.0
2120 }
2121 fn new_with_visit<F: CstFacade, E>(
2122 index: CstNodeId,
2123 tree: &F,
2124 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2125 ) -> Result<Self, CstConstructError<E>> {
2126 tree.collect_nodes(
2127 index,
2128 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockEnd6)],
2129 |[index], visit| Ok((Self(index), visit)),
2130 visit_ignored,
2131 )
2132 }
2133 fn kind(&self) -> NonTerminalKind {
2134 NonTerminalKind::CodeBlockEnd6
2135 }
2136 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2137 &self,
2138 tree: &F,
2139 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2140 visit_ignored: &'v mut V,
2141 ) -> Result<O, CstConstructError<E>> {
2142 tree.collect_nodes(
2143 self.0,
2144 [NodeKind::Terminal(TerminalKind::CodeBlockEnd6)],
2145 |[code_block_end_6], visit_ignored| {
2146 Ok(visit(
2147 CodeBlockEnd6View {
2148 code_block_end_6: CodeBlockEnd6(code_block_end_6),
2149 },
2150 visit_ignored,
2151 ))
2152 },
2153 visit_ignored,
2154 )
2155 }
2156}
2157#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2158pub struct CodeBlockEnd6View {
2159 pub code_block_end_6: CodeBlockEnd6,
2160}
2161impl CodeBlockEnd6View {}
2162#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2163pub struct CodeBlockStart3Handle(pub(crate) super::tree::CstNodeId);
2164impl NonTerminalHandle for CodeBlockStart3Handle {
2165 type View = CodeBlockStart3View;
2166 fn node_id(&self) -> CstNodeId {
2167 self.0
2168 }
2169 fn new_with_visit<F: CstFacade, E>(
2170 index: CstNodeId,
2171 tree: &F,
2172 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2173 ) -> Result<Self, CstConstructError<E>> {
2174 tree.collect_nodes(
2175 index,
2176 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart3)],
2177 |[index], visit| Ok((Self(index), visit)),
2178 visit_ignored,
2179 )
2180 }
2181 fn kind(&self) -> NonTerminalKind {
2182 NonTerminalKind::CodeBlockStart3
2183 }
2184 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2185 &self,
2186 tree: &F,
2187 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2188 visit_ignored: &'v mut V,
2189 ) -> Result<O, CstConstructError<E>> {
2190 tree.collect_nodes(
2191 self.0,
2192 [NodeKind::Terminal(TerminalKind::CodeBlockStart3)],
2193 |[code_block_start_3], visit_ignored| {
2194 Ok(visit(
2195 CodeBlockStart3View {
2196 code_block_start_3: CodeBlockStart3(code_block_start_3),
2197 },
2198 visit_ignored,
2199 ))
2200 },
2201 visit_ignored,
2202 )
2203 }
2204}
2205#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2206pub struct CodeBlockStart3View {
2207 pub code_block_start_3: CodeBlockStart3,
2208}
2209impl CodeBlockStart3View {}
2210#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2211pub struct CodeBlockStart4Handle(pub(crate) super::tree::CstNodeId);
2212impl NonTerminalHandle for CodeBlockStart4Handle {
2213 type View = CodeBlockStart4View;
2214 fn node_id(&self) -> CstNodeId {
2215 self.0
2216 }
2217 fn new_with_visit<F: CstFacade, E>(
2218 index: CstNodeId,
2219 tree: &F,
2220 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2221 ) -> Result<Self, CstConstructError<E>> {
2222 tree.collect_nodes(
2223 index,
2224 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart4)],
2225 |[index], visit| Ok((Self(index), visit)),
2226 visit_ignored,
2227 )
2228 }
2229 fn kind(&self) -> NonTerminalKind {
2230 NonTerminalKind::CodeBlockStart4
2231 }
2232 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2233 &self,
2234 tree: &F,
2235 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2236 visit_ignored: &'v mut V,
2237 ) -> Result<O, CstConstructError<E>> {
2238 tree.collect_nodes(
2239 self.0,
2240 [NodeKind::Terminal(TerminalKind::CodeBlockStart4)],
2241 |[code_block_start_4], visit_ignored| {
2242 Ok(visit(
2243 CodeBlockStart4View {
2244 code_block_start_4: CodeBlockStart4(code_block_start_4),
2245 },
2246 visit_ignored,
2247 ))
2248 },
2249 visit_ignored,
2250 )
2251 }
2252}
2253#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2254pub struct CodeBlockStart4View {
2255 pub code_block_start_4: CodeBlockStart4,
2256}
2257impl CodeBlockStart4View {}
2258#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2259pub struct CodeBlockStart5Handle(pub(crate) super::tree::CstNodeId);
2260impl NonTerminalHandle for CodeBlockStart5Handle {
2261 type View = CodeBlockStart5View;
2262 fn node_id(&self) -> CstNodeId {
2263 self.0
2264 }
2265 fn new_with_visit<F: CstFacade, E>(
2266 index: CstNodeId,
2267 tree: &F,
2268 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2269 ) -> Result<Self, CstConstructError<E>> {
2270 tree.collect_nodes(
2271 index,
2272 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart5)],
2273 |[index], visit| Ok((Self(index), visit)),
2274 visit_ignored,
2275 )
2276 }
2277 fn kind(&self) -> NonTerminalKind {
2278 NonTerminalKind::CodeBlockStart5
2279 }
2280 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2281 &self,
2282 tree: &F,
2283 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2284 visit_ignored: &'v mut V,
2285 ) -> Result<O, CstConstructError<E>> {
2286 tree.collect_nodes(
2287 self.0,
2288 [NodeKind::Terminal(TerminalKind::CodeBlockStart5)],
2289 |[code_block_start_5], visit_ignored| {
2290 Ok(visit(
2291 CodeBlockStart5View {
2292 code_block_start_5: CodeBlockStart5(code_block_start_5),
2293 },
2294 visit_ignored,
2295 ))
2296 },
2297 visit_ignored,
2298 )
2299 }
2300}
2301#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2302pub struct CodeBlockStart5View {
2303 pub code_block_start_5: CodeBlockStart5,
2304}
2305impl CodeBlockStart5View {}
2306#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2307pub struct CodeBlockStart6Handle(pub(crate) super::tree::CstNodeId);
2308impl NonTerminalHandle for CodeBlockStart6Handle {
2309 type View = CodeBlockStart6View;
2310 fn node_id(&self) -> CstNodeId {
2311 self.0
2312 }
2313 fn new_with_visit<F: CstFacade, E>(
2314 index: CstNodeId,
2315 tree: &F,
2316 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2317 ) -> Result<Self, CstConstructError<E>> {
2318 tree.collect_nodes(
2319 index,
2320 [NodeKind::NonTerminal(NonTerminalKind::CodeBlockStart6)],
2321 |[index], visit| Ok((Self(index), visit)),
2322 visit_ignored,
2323 )
2324 }
2325 fn kind(&self) -> NonTerminalKind {
2326 NonTerminalKind::CodeBlockStart6
2327 }
2328 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2329 &self,
2330 tree: &F,
2331 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2332 visit_ignored: &'v mut V,
2333 ) -> Result<O, CstConstructError<E>> {
2334 tree.collect_nodes(
2335 self.0,
2336 [NodeKind::Terminal(TerminalKind::CodeBlockStart6)],
2337 |[code_block_start_6], visit_ignored| {
2338 Ok(visit(
2339 CodeBlockStart6View {
2340 code_block_start_6: CodeBlockStart6(code_block_start_6),
2341 },
2342 visit_ignored,
2343 ))
2344 },
2345 visit_ignored,
2346 )
2347 }
2348}
2349#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2350pub struct CodeBlockStart6View {
2351 pub code_block_start_6: CodeBlockStart6,
2352}
2353impl CodeBlockStart6View {}
2354#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2355pub struct CommaHandle(pub(crate) super::tree::CstNodeId);
2356impl NonTerminalHandle for CommaHandle {
2357 type View = CommaView;
2358 fn node_id(&self) -> CstNodeId {
2359 self.0
2360 }
2361 fn new_with_visit<F: CstFacade, E>(
2362 index: CstNodeId,
2363 tree: &F,
2364 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2365 ) -> Result<Self, CstConstructError<E>> {
2366 tree.collect_nodes(
2367 index,
2368 [NodeKind::NonTerminal(NonTerminalKind::Comma)],
2369 |[index], visit| Ok((Self(index), visit)),
2370 visit_ignored,
2371 )
2372 }
2373 fn kind(&self) -> NonTerminalKind {
2374 NonTerminalKind::Comma
2375 }
2376 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2377 &self,
2378 tree: &F,
2379 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2380 visit_ignored: &'v mut V,
2381 ) -> Result<O, CstConstructError<E>> {
2382 tree.collect_nodes(
2383 self.0,
2384 [NodeKind::Terminal(TerminalKind::Comma)],
2385 |[comma], visit_ignored| {
2386 Ok(visit(
2387 CommaView {
2388 comma: Comma(comma),
2389 },
2390 visit_ignored,
2391 ))
2392 },
2393 visit_ignored,
2394 )
2395 }
2396}
2397#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2398pub struct CommaView {
2399 pub comma: Comma,
2400}
2401impl CommaView {}
2402#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2403pub struct ContinueHandle(pub(crate) super::tree::CstNodeId);
2404impl NonTerminalHandle for ContinueHandle {
2405 type View = ContinueView;
2406 fn node_id(&self) -> CstNodeId {
2407 self.0
2408 }
2409 fn new_with_visit<F: CstFacade, E>(
2410 index: CstNodeId,
2411 tree: &F,
2412 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2413 ) -> Result<Self, CstConstructError<E>> {
2414 tree.collect_nodes(
2415 index,
2416 [NodeKind::NonTerminal(NonTerminalKind::Continue)],
2417 |[index], visit| Ok((Self(index), visit)),
2418 visit_ignored,
2419 )
2420 }
2421 fn kind(&self) -> NonTerminalKind {
2422 NonTerminalKind::Continue
2423 }
2424 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2425 &self,
2426 tree: &F,
2427 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2428 visit_ignored: &'v mut V,
2429 ) -> Result<O, CstConstructError<E>> {
2430 tree.collect_nodes(
2431 self.0,
2432 [NodeKind::Terminal(TerminalKind::Esc)],
2433 |[esc], visit_ignored| Ok(visit(ContinueView { esc: Esc(esc) }, visit_ignored)),
2434 visit_ignored,
2435 )
2436 }
2437}
2438#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2439pub struct ContinueView {
2440 pub esc: Esc,
2441}
2442impl ContinueView {}
2443#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2444pub struct DelimCodeHandle(pub(crate) super::tree::CstNodeId);
2445impl NonTerminalHandle for DelimCodeHandle {
2446 type View = DelimCodeView;
2447 fn node_id(&self) -> CstNodeId {
2448 self.0
2449 }
2450 fn new_with_visit<F: CstFacade, E>(
2451 index: CstNodeId,
2452 tree: &F,
2453 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2454 ) -> Result<Self, CstConstructError<E>> {
2455 tree.collect_nodes(
2456 index,
2457 [NodeKind::NonTerminal(NonTerminalKind::DelimCode)],
2458 |[index], visit| Ok((Self(index), visit)),
2459 visit_ignored,
2460 )
2461 }
2462 fn kind(&self) -> NonTerminalKind {
2463 NonTerminalKind::DelimCode
2464 }
2465 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2466 &self,
2467 tree: &F,
2468 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2469 visit_ignored: &'v mut V,
2470 ) -> Result<O, CstConstructError<E>> {
2471 let mut children = tree.children(self.0);
2472 let Some(child) = children.next() else {
2473 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
2474 };
2475 let Some(child_data) = tree.node_data(child) else {
2476 return Err(ViewConstructionError::NodeIdNotFound { node: child });
2477 };
2478 let variant = match child_data.node_kind() {
2479 NodeKind::NonTerminal(NonTerminalKind::DelimCode3) => {
2480 DelimCodeView::DelimCode3(DelimCode3Handle(child))
2481 }
2482 NodeKind::NonTerminal(NonTerminalKind::DelimCode2) => {
2483 DelimCodeView::DelimCode2(DelimCode2Handle(child))
2484 }
2485 NodeKind::NonTerminal(NonTerminalKind::DelimCode1) => {
2486 DelimCodeView::DelimCode1(DelimCode1Handle(child))
2487 }
2488 _ => {
2489 return Err(ViewConstructionError::UnexpectedNode {
2490 node: child,
2491 data: child_data,
2492 expected_kind: child_data.node_kind(),
2493 });
2494 }
2495 };
2496 let (result, _visit) = visit(variant, visit_ignored);
2497 if let Some(extra_child) = children.next() {
2498 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
2499 }
2500 Ok(result)
2501 }
2502}
2503#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2504pub enum DelimCodeView {
2505 DelimCode3(DelimCode3Handle),
2506 DelimCode2(DelimCode2Handle),
2507 DelimCode1(DelimCode1Handle),
2508}
2509impl DelimCodeView {}
2510#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2511pub struct DelimCode1Handle(pub(crate) super::tree::CstNodeId);
2512impl NonTerminalHandle for DelimCode1Handle {
2513 type View = DelimCode1View;
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::DelimCode1)],
2525 |[index], visit| Ok((Self(index), visit)),
2526 visit_ignored,
2527 )
2528 }
2529 fn kind(&self) -> NonTerminalKind {
2530 NonTerminalKind::DelimCode1
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 tree.collect_nodes(
2539 self.0,
2540 [
2541 NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart1),
2542 NodeKind::NonTerminal(NonTerminalKind::DelimCode1List),
2543 NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd1),
2544 ],
2545 |[delim_code_start_1, delim_code_1_list, delim_code_end_1], visit_ignored| {
2546 Ok(visit(
2547 DelimCode1View {
2548 delim_code_start_1: DelimCodeStart1Handle(delim_code_start_1),
2549 delim_code_1_list: DelimCode1ListHandle(delim_code_1_list),
2550 delim_code_end_1: DelimCodeEnd1Handle(delim_code_end_1),
2551 },
2552 visit_ignored,
2553 ))
2554 },
2555 visit_ignored,
2556 )
2557 }
2558}
2559#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2560pub struct DelimCode1View {
2561 pub delim_code_start_1: DelimCodeStart1Handle,
2562 pub delim_code_1_list: DelimCode1ListHandle,
2563 pub delim_code_end_1: DelimCodeEnd1Handle,
2564}
2565impl DelimCode1View {}
2566#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2567pub struct DelimCode1ListHandle(pub(crate) super::tree::CstNodeId);
2568impl NonTerminalHandle for DelimCode1ListHandle {
2569 type View = Option<DelimCode1ListView>;
2570 fn node_id(&self) -> CstNodeId {
2571 self.0
2572 }
2573 fn new_with_visit<F: CstFacade, E>(
2574 index: CstNodeId,
2575 tree: &F,
2576 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2577 ) -> Result<Self, CstConstructError<E>> {
2578 tree.collect_nodes(
2579 index,
2580 [NodeKind::NonTerminal(NonTerminalKind::DelimCode1List)],
2581 |[index], visit| Ok((Self(index), visit)),
2582 visit_ignored,
2583 )
2584 }
2585 fn kind(&self) -> NonTerminalKind {
2586 NonTerminalKind::DelimCode1List
2587 }
2588 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2589 &self,
2590 tree: &F,
2591 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2592 visit_ignored: &'v mut V,
2593 ) -> Result<O, CstConstructError<E>> {
2594 if tree.has_no_children(self.0) {
2595 return Ok(visit(None, visit_ignored).0);
2596 }
2597 tree.collect_nodes(
2598 self.0,
2599 [
2600 NodeKind::NonTerminal(NonTerminalKind::DelimCode1ListGroup),
2601 NodeKind::NonTerminal(NonTerminalKind::DelimCode1List),
2602 ],
2603 |[delim_code_1_list_group, delim_code_1_list], visit_ignored| {
2604 Ok(visit(
2605 Some(DelimCode1ListView {
2606 delim_code_1_list_group: DelimCode1ListGroupHandle(delim_code_1_list_group),
2607 delim_code_1_list: DelimCode1ListHandle(delim_code_1_list),
2608 }),
2609 visit_ignored,
2610 ))
2611 },
2612 visit_ignored,
2613 )
2614 }
2615}
2616#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2617pub struct DelimCode1ListView {
2618 pub delim_code_1_list_group: DelimCode1ListGroupHandle,
2619 pub delim_code_1_list: DelimCode1ListHandle,
2620}
2621impl<F: CstFacade> RecursiveView<F> for DelimCode1ListView {
2622 type Item = DelimCode1ListGroupHandle;
2623 fn get_all_with_visit<E>(
2624 &self,
2625 tree: &F,
2626 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2627 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2628 let mut items = Vec::new();
2629 let mut current_view = Some(*self);
2630 while let Some(item) = current_view {
2631 let Self {
2632 delim_code_1_list_group,
2633 ..
2634 } = item;
2635 items.push(delim_code_1_list_group);
2636 item.delim_code_1_list.get_view_with_visit(
2637 tree,
2638 |view, visit_ignored| {
2639 current_view = view;
2640 ((), visit_ignored)
2641 },
2642 visit_ignored,
2643 )?;
2644 }
2645 Ok(items)
2646 }
2647}
2648#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2649pub struct DelimCode1ListGroupHandle(pub(crate) super::tree::CstNodeId);
2650impl NonTerminalHandle for DelimCode1ListGroupHandle {
2651 type View = DelimCode1ListGroupView;
2652 fn node_id(&self) -> CstNodeId {
2653 self.0
2654 }
2655 fn new_with_visit<F: CstFacade, E>(
2656 index: CstNodeId,
2657 tree: &F,
2658 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2659 ) -> Result<Self, CstConstructError<E>> {
2660 tree.collect_nodes(
2661 index,
2662 [NodeKind::NonTerminal(NonTerminalKind::DelimCode1ListGroup)],
2663 |[index], visit| Ok((Self(index), visit)),
2664 visit_ignored,
2665 )
2666 }
2667 fn kind(&self) -> NonTerminalKind {
2668 NonTerminalKind::DelimCode1ListGroup
2669 }
2670 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2671 &self,
2672 tree: &F,
2673 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2674 visit_ignored: &'v mut V,
2675 ) -> Result<O, CstConstructError<E>> {
2676 let mut children = tree.children(self.0);
2677 let Some(child) = children.next() else {
2678 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
2679 };
2680 let Some(child_data) = tree.node_data(child) else {
2681 return Err(ViewConstructionError::NodeIdNotFound { node: child });
2682 };
2683 let variant = match child_data.node_kind() {
2684 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
2685 DelimCode1ListGroupView::NoBacktick(NoBacktickHandle(child))
2686 }
2687 NodeKind::NonTerminal(NonTerminalKind::BacktickDelim) => {
2688 DelimCode1ListGroupView::BacktickDelim(BacktickDelimHandle(child))
2689 }
2690 _ => {
2691 return Err(ViewConstructionError::UnexpectedNode {
2692 node: child,
2693 data: child_data,
2694 expected_kind: child_data.node_kind(),
2695 });
2696 }
2697 };
2698 let (result, _visit) = visit(variant, visit_ignored);
2699 if let Some(extra_child) = children.next() {
2700 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
2701 }
2702 Ok(result)
2703 }
2704}
2705#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2706pub enum DelimCode1ListGroupView {
2707 NoBacktick(NoBacktickHandle),
2708 BacktickDelim(BacktickDelimHandle),
2709}
2710impl DelimCode1ListGroupView {}
2711#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2712pub struct DelimCode2Handle(pub(crate) super::tree::CstNodeId);
2713impl NonTerminalHandle for DelimCode2Handle {
2714 type View = DelimCode2View;
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::DelimCode2)],
2726 |[index], visit| Ok((Self(index), visit)),
2727 visit_ignored,
2728 )
2729 }
2730 fn kind(&self) -> NonTerminalKind {
2731 NonTerminalKind::DelimCode2
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 tree.collect_nodes(
2740 self.0,
2741 [
2742 NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart2),
2743 NodeKind::NonTerminal(NonTerminalKind::DelimCode2List),
2744 NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd2),
2745 ],
2746 |[delim_code_start_2, delim_code_2_list, delim_code_end_2], visit_ignored| {
2747 Ok(visit(
2748 DelimCode2View {
2749 delim_code_start_2: DelimCodeStart2Handle(delim_code_start_2),
2750 delim_code_2_list: DelimCode2ListHandle(delim_code_2_list),
2751 delim_code_end_2: DelimCodeEnd2Handle(delim_code_end_2),
2752 },
2753 visit_ignored,
2754 ))
2755 },
2756 visit_ignored,
2757 )
2758 }
2759}
2760#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2761pub struct DelimCode2View {
2762 pub delim_code_start_2: DelimCodeStart2Handle,
2763 pub delim_code_2_list: DelimCode2ListHandle,
2764 pub delim_code_end_2: DelimCodeEnd2Handle,
2765}
2766impl DelimCode2View {}
2767#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2768pub struct DelimCode2ListHandle(pub(crate) super::tree::CstNodeId);
2769impl NonTerminalHandle for DelimCode2ListHandle {
2770 type View = Option<DelimCode2ListView>;
2771 fn node_id(&self) -> CstNodeId {
2772 self.0
2773 }
2774 fn new_with_visit<F: CstFacade, E>(
2775 index: CstNodeId,
2776 tree: &F,
2777 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2778 ) -> Result<Self, CstConstructError<E>> {
2779 tree.collect_nodes(
2780 index,
2781 [NodeKind::NonTerminal(NonTerminalKind::DelimCode2List)],
2782 |[index], visit| Ok((Self(index), visit)),
2783 visit_ignored,
2784 )
2785 }
2786 fn kind(&self) -> NonTerminalKind {
2787 NonTerminalKind::DelimCode2List
2788 }
2789 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2790 &self,
2791 tree: &F,
2792 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2793 visit_ignored: &'v mut V,
2794 ) -> Result<O, CstConstructError<E>> {
2795 if tree.has_no_children(self.0) {
2796 return Ok(visit(None, visit_ignored).0);
2797 }
2798 tree.collect_nodes(
2799 self.0,
2800 [
2801 NodeKind::NonTerminal(NonTerminalKind::DelimCode2ListGroup),
2802 NodeKind::NonTerminal(NonTerminalKind::DelimCode2List),
2803 ],
2804 |[delim_code_2_list_group, delim_code_2_list], visit_ignored| {
2805 Ok(visit(
2806 Some(DelimCode2ListView {
2807 delim_code_2_list_group: DelimCode2ListGroupHandle(delim_code_2_list_group),
2808 delim_code_2_list: DelimCode2ListHandle(delim_code_2_list),
2809 }),
2810 visit_ignored,
2811 ))
2812 },
2813 visit_ignored,
2814 )
2815 }
2816}
2817#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2818pub struct DelimCode2ListView {
2819 pub delim_code_2_list_group: DelimCode2ListGroupHandle,
2820 pub delim_code_2_list: DelimCode2ListHandle,
2821}
2822impl<F: CstFacade> RecursiveView<F> for DelimCode2ListView {
2823 type Item = DelimCode2ListGroupHandle;
2824 fn get_all_with_visit<E>(
2825 &self,
2826 tree: &F,
2827 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2828 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
2829 let mut items = Vec::new();
2830 let mut current_view = Some(*self);
2831 while let Some(item) = current_view {
2832 let Self {
2833 delim_code_2_list_group,
2834 ..
2835 } = item;
2836 items.push(delim_code_2_list_group);
2837 item.delim_code_2_list.get_view_with_visit(
2838 tree,
2839 |view, visit_ignored| {
2840 current_view = view;
2841 ((), visit_ignored)
2842 },
2843 visit_ignored,
2844 )?;
2845 }
2846 Ok(items)
2847 }
2848}
2849#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2850pub struct DelimCode2ListGroupHandle(pub(crate) super::tree::CstNodeId);
2851impl NonTerminalHandle for DelimCode2ListGroupHandle {
2852 type View = DelimCode2ListGroupView;
2853 fn node_id(&self) -> CstNodeId {
2854 self.0
2855 }
2856 fn new_with_visit<F: CstFacade, E>(
2857 index: CstNodeId,
2858 tree: &F,
2859 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2860 ) -> Result<Self, CstConstructError<E>> {
2861 tree.collect_nodes(
2862 index,
2863 [NodeKind::NonTerminal(NonTerminalKind::DelimCode2ListGroup)],
2864 |[index], visit| Ok((Self(index), visit)),
2865 visit_ignored,
2866 )
2867 }
2868 fn kind(&self) -> NonTerminalKind {
2869 NonTerminalKind::DelimCode2ListGroup
2870 }
2871 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2872 &self,
2873 tree: &F,
2874 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2875 visit_ignored: &'v mut V,
2876 ) -> Result<O, CstConstructError<E>> {
2877 let mut children = tree.children(self.0);
2878 let Some(child) = children.next() else {
2879 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
2880 };
2881 let Some(child_data) = tree.node_data(child) else {
2882 return Err(ViewConstructionError::NodeIdNotFound { node: child });
2883 };
2884 let variant = match child_data.node_kind() {
2885 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
2886 DelimCode2ListGroupView::NoBacktick(NoBacktickHandle(child))
2887 }
2888 NodeKind::NonTerminal(NonTerminalKind::BacktickDelim) => {
2889 DelimCode2ListGroupView::BacktickDelim(BacktickDelimHandle(child))
2890 }
2891 _ => {
2892 return Err(ViewConstructionError::UnexpectedNode {
2893 node: child,
2894 data: child_data,
2895 expected_kind: child_data.node_kind(),
2896 });
2897 }
2898 };
2899 let (result, _visit) = visit(variant, visit_ignored);
2900 if let Some(extra_child) = children.next() {
2901 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
2902 }
2903 Ok(result)
2904 }
2905}
2906#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2907pub enum DelimCode2ListGroupView {
2908 NoBacktick(NoBacktickHandle),
2909 BacktickDelim(BacktickDelimHandle),
2910}
2911impl DelimCode2ListGroupView {}
2912#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2913pub struct DelimCode3Handle(pub(crate) super::tree::CstNodeId);
2914impl NonTerminalHandle for DelimCode3Handle {
2915 type View = DelimCode3View;
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::DelimCode3)],
2927 |[index], visit| Ok((Self(index), visit)),
2928 visit_ignored,
2929 )
2930 }
2931 fn kind(&self) -> NonTerminalKind {
2932 NonTerminalKind::DelimCode3
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 tree.collect_nodes(
2941 self.0,
2942 [
2943 NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart3),
2944 NodeKind::NonTerminal(NonTerminalKind::DelimCode3List),
2945 NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd3),
2946 ],
2947 |[delim_code_start_3, delim_code_3_list, delim_code_end_3], visit_ignored| {
2948 Ok(visit(
2949 DelimCode3View {
2950 delim_code_start_3: DelimCodeStart3Handle(delim_code_start_3),
2951 delim_code_3_list: DelimCode3ListHandle(delim_code_3_list),
2952 delim_code_end_3: DelimCodeEnd3Handle(delim_code_end_3),
2953 },
2954 visit_ignored,
2955 ))
2956 },
2957 visit_ignored,
2958 )
2959 }
2960}
2961#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2962pub struct DelimCode3View {
2963 pub delim_code_start_3: DelimCodeStart3Handle,
2964 pub delim_code_3_list: DelimCode3ListHandle,
2965 pub delim_code_end_3: DelimCodeEnd3Handle,
2966}
2967impl DelimCode3View {}
2968#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2969pub struct DelimCode3ListHandle(pub(crate) super::tree::CstNodeId);
2970impl NonTerminalHandle for DelimCode3ListHandle {
2971 type View = Option<DelimCode3ListView>;
2972 fn node_id(&self) -> CstNodeId {
2973 self.0
2974 }
2975 fn new_with_visit<F: CstFacade, E>(
2976 index: CstNodeId,
2977 tree: &F,
2978 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
2979 ) -> Result<Self, CstConstructError<E>> {
2980 tree.collect_nodes(
2981 index,
2982 [NodeKind::NonTerminal(NonTerminalKind::DelimCode3List)],
2983 |[index], visit| Ok((Self(index), visit)),
2984 visit_ignored,
2985 )
2986 }
2987 fn kind(&self) -> NonTerminalKind {
2988 NonTerminalKind::DelimCode3List
2989 }
2990 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
2991 &self,
2992 tree: &F,
2993 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
2994 visit_ignored: &'v mut V,
2995 ) -> Result<O, CstConstructError<E>> {
2996 if tree.has_no_children(self.0) {
2997 return Ok(visit(None, visit_ignored).0);
2998 }
2999 tree.collect_nodes(
3000 self.0,
3001 [
3002 NodeKind::NonTerminal(NonTerminalKind::DelimCode3ListGroup),
3003 NodeKind::NonTerminal(NonTerminalKind::DelimCode3List),
3004 ],
3005 |[delim_code_3_list_group, delim_code_3_list], visit_ignored| {
3006 Ok(visit(
3007 Some(DelimCode3ListView {
3008 delim_code_3_list_group: DelimCode3ListGroupHandle(delim_code_3_list_group),
3009 delim_code_3_list: DelimCode3ListHandle(delim_code_3_list),
3010 }),
3011 visit_ignored,
3012 ))
3013 },
3014 visit_ignored,
3015 )
3016 }
3017}
3018#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3019pub struct DelimCode3ListView {
3020 pub delim_code_3_list_group: DelimCode3ListGroupHandle,
3021 pub delim_code_3_list: DelimCode3ListHandle,
3022}
3023impl<F: CstFacade> RecursiveView<F> for DelimCode3ListView {
3024 type Item = DelimCode3ListGroupHandle;
3025 fn get_all_with_visit<E>(
3026 &self,
3027 tree: &F,
3028 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3029 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
3030 let mut items = Vec::new();
3031 let mut current_view = Some(*self);
3032 while let Some(item) = current_view {
3033 let Self {
3034 delim_code_3_list_group,
3035 ..
3036 } = item;
3037 items.push(delim_code_3_list_group);
3038 item.delim_code_3_list.get_view_with_visit(
3039 tree,
3040 |view, visit_ignored| {
3041 current_view = view;
3042 ((), visit_ignored)
3043 },
3044 visit_ignored,
3045 )?;
3046 }
3047 Ok(items)
3048 }
3049}
3050#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3051pub struct DelimCode3ListGroupHandle(pub(crate) super::tree::CstNodeId);
3052impl NonTerminalHandle for DelimCode3ListGroupHandle {
3053 type View = DelimCode3ListGroupView;
3054 fn node_id(&self) -> CstNodeId {
3055 self.0
3056 }
3057 fn new_with_visit<F: CstFacade, E>(
3058 index: CstNodeId,
3059 tree: &F,
3060 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3061 ) -> Result<Self, CstConstructError<E>> {
3062 tree.collect_nodes(
3063 index,
3064 [NodeKind::NonTerminal(NonTerminalKind::DelimCode3ListGroup)],
3065 |[index], visit| Ok((Self(index), visit)),
3066 visit_ignored,
3067 )
3068 }
3069 fn kind(&self) -> NonTerminalKind {
3070 NonTerminalKind::DelimCode3ListGroup
3071 }
3072 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3073 &self,
3074 tree: &F,
3075 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3076 visit_ignored: &'v mut V,
3077 ) -> Result<O, CstConstructError<E>> {
3078 let mut children = tree.children(self.0);
3079 let Some(child) = children.next() else {
3080 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3081 };
3082 let Some(child_data) = tree.node_data(child) else {
3083 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3084 };
3085 let variant = match child_data.node_kind() {
3086 NodeKind::NonTerminal(NonTerminalKind::NoBacktick) => {
3087 DelimCode3ListGroupView::NoBacktick(NoBacktickHandle(child))
3088 }
3089 NodeKind::NonTerminal(NonTerminalKind::BacktickDelim) => {
3090 DelimCode3ListGroupView::BacktickDelim(BacktickDelimHandle(child))
3091 }
3092 _ => {
3093 return Err(ViewConstructionError::UnexpectedNode {
3094 node: child,
3095 data: child_data,
3096 expected_kind: child_data.node_kind(),
3097 });
3098 }
3099 };
3100 let (result, _visit) = visit(variant, visit_ignored);
3101 if let Some(extra_child) = children.next() {
3102 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3103 }
3104 Ok(result)
3105 }
3106}
3107#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3108pub enum DelimCode3ListGroupView {
3109 NoBacktick(NoBacktickHandle),
3110 BacktickDelim(BacktickDelimHandle),
3111}
3112impl DelimCode3ListGroupView {}
3113#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3114pub struct DelimCodeEnd1Handle(pub(crate) super::tree::CstNodeId);
3115impl NonTerminalHandle for DelimCodeEnd1Handle {
3116 type View = DelimCodeEnd1View;
3117 fn node_id(&self) -> CstNodeId {
3118 self.0
3119 }
3120 fn new_with_visit<F: CstFacade, E>(
3121 index: CstNodeId,
3122 tree: &F,
3123 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3124 ) -> Result<Self, CstConstructError<E>> {
3125 tree.collect_nodes(
3126 index,
3127 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd1)],
3128 |[index], visit| Ok((Self(index), visit)),
3129 visit_ignored,
3130 )
3131 }
3132 fn kind(&self) -> NonTerminalKind {
3133 NonTerminalKind::DelimCodeEnd1
3134 }
3135 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3136 &self,
3137 tree: &F,
3138 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3139 visit_ignored: &'v mut V,
3140 ) -> Result<O, CstConstructError<E>> {
3141 tree.collect_nodes(
3142 self.0,
3143 [NodeKind::Terminal(TerminalKind::DelimCodeEnd1)],
3144 |[delim_code_end_1], visit_ignored| {
3145 Ok(visit(
3146 DelimCodeEnd1View {
3147 delim_code_end_1: DelimCodeEnd1(delim_code_end_1),
3148 },
3149 visit_ignored,
3150 ))
3151 },
3152 visit_ignored,
3153 )
3154 }
3155}
3156#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3157pub struct DelimCodeEnd1View {
3158 pub delim_code_end_1: DelimCodeEnd1,
3159}
3160impl DelimCodeEnd1View {}
3161#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3162pub struct DelimCodeEnd2Handle(pub(crate) super::tree::CstNodeId);
3163impl NonTerminalHandle for DelimCodeEnd2Handle {
3164 type View = DelimCodeEnd2View;
3165 fn node_id(&self) -> CstNodeId {
3166 self.0
3167 }
3168 fn new_with_visit<F: CstFacade, E>(
3169 index: CstNodeId,
3170 tree: &F,
3171 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3172 ) -> Result<Self, CstConstructError<E>> {
3173 tree.collect_nodes(
3174 index,
3175 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd2)],
3176 |[index], visit| Ok((Self(index), visit)),
3177 visit_ignored,
3178 )
3179 }
3180 fn kind(&self) -> NonTerminalKind {
3181 NonTerminalKind::DelimCodeEnd2
3182 }
3183 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3184 &self,
3185 tree: &F,
3186 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3187 visit_ignored: &'v mut V,
3188 ) -> Result<O, CstConstructError<E>> {
3189 tree.collect_nodes(
3190 self.0,
3191 [NodeKind::Terminal(TerminalKind::DelimCodeEnd2)],
3192 |[delim_code_end_2], visit_ignored| {
3193 Ok(visit(
3194 DelimCodeEnd2View {
3195 delim_code_end_2: DelimCodeEnd2(delim_code_end_2),
3196 },
3197 visit_ignored,
3198 ))
3199 },
3200 visit_ignored,
3201 )
3202 }
3203}
3204#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3205pub struct DelimCodeEnd2View {
3206 pub delim_code_end_2: DelimCodeEnd2,
3207}
3208impl DelimCodeEnd2View {}
3209#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3210pub struct DelimCodeEnd3Handle(pub(crate) super::tree::CstNodeId);
3211impl NonTerminalHandle for DelimCodeEnd3Handle {
3212 type View = DelimCodeEnd3View;
3213 fn node_id(&self) -> CstNodeId {
3214 self.0
3215 }
3216 fn new_with_visit<F: CstFacade, E>(
3217 index: CstNodeId,
3218 tree: &F,
3219 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3220 ) -> Result<Self, CstConstructError<E>> {
3221 tree.collect_nodes(
3222 index,
3223 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeEnd3)],
3224 |[index], visit| Ok((Self(index), visit)),
3225 visit_ignored,
3226 )
3227 }
3228 fn kind(&self) -> NonTerminalKind {
3229 NonTerminalKind::DelimCodeEnd3
3230 }
3231 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3232 &self,
3233 tree: &F,
3234 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3235 visit_ignored: &'v mut V,
3236 ) -> Result<O, CstConstructError<E>> {
3237 tree.collect_nodes(
3238 self.0,
3239 [NodeKind::Terminal(TerminalKind::DelimCodeEnd3)],
3240 |[delim_code_end_3], visit_ignored| {
3241 Ok(visit(
3242 DelimCodeEnd3View {
3243 delim_code_end_3: DelimCodeEnd3(delim_code_end_3),
3244 },
3245 visit_ignored,
3246 ))
3247 },
3248 visit_ignored,
3249 )
3250 }
3251}
3252#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3253pub struct DelimCodeEnd3View {
3254 pub delim_code_end_3: DelimCodeEnd3,
3255}
3256impl DelimCodeEnd3View {}
3257#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3258pub struct DelimCodeStart1Handle(pub(crate) super::tree::CstNodeId);
3259impl NonTerminalHandle for DelimCodeStart1Handle {
3260 type View = DelimCodeStart1View;
3261 fn node_id(&self) -> CstNodeId {
3262 self.0
3263 }
3264 fn new_with_visit<F: CstFacade, E>(
3265 index: CstNodeId,
3266 tree: &F,
3267 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3268 ) -> Result<Self, CstConstructError<E>> {
3269 tree.collect_nodes(
3270 index,
3271 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart1)],
3272 |[index], visit| Ok((Self(index), visit)),
3273 visit_ignored,
3274 )
3275 }
3276 fn kind(&self) -> NonTerminalKind {
3277 NonTerminalKind::DelimCodeStart1
3278 }
3279 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3280 &self,
3281 tree: &F,
3282 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3283 visit_ignored: &'v mut V,
3284 ) -> Result<O, CstConstructError<E>> {
3285 tree.collect_nodes(
3286 self.0,
3287 [NodeKind::Terminal(TerminalKind::DelimCodeStart1)],
3288 |[delim_code_start_1], visit_ignored| {
3289 Ok(visit(
3290 DelimCodeStart1View {
3291 delim_code_start_1: DelimCodeStart1(delim_code_start_1),
3292 },
3293 visit_ignored,
3294 ))
3295 },
3296 visit_ignored,
3297 )
3298 }
3299}
3300#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3301pub struct DelimCodeStart1View {
3302 pub delim_code_start_1: DelimCodeStart1,
3303}
3304impl DelimCodeStart1View {}
3305#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3306pub struct DelimCodeStart2Handle(pub(crate) super::tree::CstNodeId);
3307impl NonTerminalHandle for DelimCodeStart2Handle {
3308 type View = DelimCodeStart2View;
3309 fn node_id(&self) -> CstNodeId {
3310 self.0
3311 }
3312 fn new_with_visit<F: CstFacade, E>(
3313 index: CstNodeId,
3314 tree: &F,
3315 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3316 ) -> Result<Self, CstConstructError<E>> {
3317 tree.collect_nodes(
3318 index,
3319 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart2)],
3320 |[index], visit| Ok((Self(index), visit)),
3321 visit_ignored,
3322 )
3323 }
3324 fn kind(&self) -> NonTerminalKind {
3325 NonTerminalKind::DelimCodeStart2
3326 }
3327 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3328 &self,
3329 tree: &F,
3330 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3331 visit_ignored: &'v mut V,
3332 ) -> Result<O, CstConstructError<E>> {
3333 tree.collect_nodes(
3334 self.0,
3335 [NodeKind::Terminal(TerminalKind::DelimCodeStart2)],
3336 |[delim_code_start_2], visit_ignored| {
3337 Ok(visit(
3338 DelimCodeStart2View {
3339 delim_code_start_2: DelimCodeStart2(delim_code_start_2),
3340 },
3341 visit_ignored,
3342 ))
3343 },
3344 visit_ignored,
3345 )
3346 }
3347}
3348#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3349pub struct DelimCodeStart2View {
3350 pub delim_code_start_2: DelimCodeStart2,
3351}
3352impl DelimCodeStart2View {}
3353#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3354pub struct DelimCodeStart3Handle(pub(crate) super::tree::CstNodeId);
3355impl NonTerminalHandle for DelimCodeStart3Handle {
3356 type View = DelimCodeStart3View;
3357 fn node_id(&self) -> CstNodeId {
3358 self.0
3359 }
3360 fn new_with_visit<F: CstFacade, E>(
3361 index: CstNodeId,
3362 tree: &F,
3363 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3364 ) -> Result<Self, CstConstructError<E>> {
3365 tree.collect_nodes(
3366 index,
3367 [NodeKind::NonTerminal(NonTerminalKind::DelimCodeStart3)],
3368 |[index], visit| Ok((Self(index), visit)),
3369 visit_ignored,
3370 )
3371 }
3372 fn kind(&self) -> NonTerminalKind {
3373 NonTerminalKind::DelimCodeStart3
3374 }
3375 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3376 &self,
3377 tree: &F,
3378 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3379 visit_ignored: &'v mut V,
3380 ) -> Result<O, CstConstructError<E>> {
3381 tree.collect_nodes(
3382 self.0,
3383 [NodeKind::Terminal(TerminalKind::DelimCodeStart3)],
3384 |[delim_code_start_3], visit_ignored| {
3385 Ok(visit(
3386 DelimCodeStart3View {
3387 delim_code_start_3: DelimCodeStart3(delim_code_start_3),
3388 },
3389 visit_ignored,
3390 ))
3391 },
3392 visit_ignored,
3393 )
3394 }
3395}
3396#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3397pub struct DelimCodeStart3View {
3398 pub delim_code_start_3: DelimCodeStart3,
3399}
3400impl DelimCodeStart3View {}
3401#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3402pub struct DotHandle(pub(crate) super::tree::CstNodeId);
3403impl NonTerminalHandle for DotHandle {
3404 type View = DotView;
3405 fn node_id(&self) -> CstNodeId {
3406 self.0
3407 }
3408 fn new_with_visit<F: CstFacade, E>(
3409 index: CstNodeId,
3410 tree: &F,
3411 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3412 ) -> Result<Self, CstConstructError<E>> {
3413 tree.collect_nodes(
3414 index,
3415 [NodeKind::NonTerminal(NonTerminalKind::Dot)],
3416 |[index], visit| Ok((Self(index), visit)),
3417 visit_ignored,
3418 )
3419 }
3420 fn kind(&self) -> NonTerminalKind {
3421 NonTerminalKind::Dot
3422 }
3423 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3424 &self,
3425 tree: &F,
3426 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3427 visit_ignored: &'v mut V,
3428 ) -> Result<O, CstConstructError<E>> {
3429 tree.collect_nodes(
3430 self.0,
3431 [NodeKind::Terminal(TerminalKind::Dot)],
3432 |[dot], visit_ignored| Ok(visit(DotView { dot: Dot(dot) }, visit_ignored)),
3433 visit_ignored,
3434 )
3435 }
3436}
3437#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3438pub struct DotView {
3439 pub dot: Dot,
3440}
3441impl DotView {}
3442#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3443pub struct DotKeyHandle(pub(crate) super::tree::CstNodeId);
3444impl NonTerminalHandle for DotKeyHandle {
3445 type View = DotKeyView;
3446 fn node_id(&self) -> CstNodeId {
3447 self.0
3448 }
3449 fn new_with_visit<F: CstFacade, E>(
3450 index: CstNodeId,
3451 tree: &F,
3452 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3453 ) -> Result<Self, CstConstructError<E>> {
3454 tree.collect_nodes(
3455 index,
3456 [NodeKind::NonTerminal(NonTerminalKind::DotKey)],
3457 |[index], visit| Ok((Self(index), visit)),
3458 visit_ignored,
3459 )
3460 }
3461 fn kind(&self) -> NonTerminalKind {
3462 NonTerminalKind::DotKey
3463 }
3464 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3465 &self,
3466 tree: &F,
3467 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3468 visit_ignored: &'v mut V,
3469 ) -> Result<O, CstConstructError<E>> {
3470 tree.collect_nodes(
3471 self.0,
3472 [
3473 NodeKind::NonTerminal(NonTerminalKind::Dot),
3474 NodeKind::NonTerminal(NonTerminalKind::Key),
3475 ],
3476 |[dot, key], visit_ignored| {
3477 Ok(visit(
3478 DotKeyView {
3479 dot: DotHandle(dot),
3480 key: KeyHandle(key),
3481 },
3482 visit_ignored,
3483 ))
3484 },
3485 visit_ignored,
3486 )
3487 }
3488}
3489#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3490pub struct DotKeyView {
3491 pub dot: DotHandle,
3492 pub key: KeyHandle,
3493}
3494impl DotKeyView {}
3495#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3496pub struct EndHandle(pub(crate) super::tree::CstNodeId);
3497impl NonTerminalHandle for EndHandle {
3498 type View = EndView;
3499 fn node_id(&self) -> CstNodeId {
3500 self.0
3501 }
3502 fn new_with_visit<F: CstFacade, E>(
3503 index: CstNodeId,
3504 tree: &F,
3505 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3506 ) -> Result<Self, CstConstructError<E>> {
3507 tree.collect_nodes(
3508 index,
3509 [NodeKind::NonTerminal(NonTerminalKind::End)],
3510 |[index], visit| Ok((Self(index), visit)),
3511 visit_ignored,
3512 )
3513 }
3514 fn kind(&self) -> NonTerminalKind {
3515 NonTerminalKind::End
3516 }
3517 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3518 &self,
3519 tree: &F,
3520 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3521 visit_ignored: &'v mut V,
3522 ) -> Result<O, CstConstructError<E>> {
3523 tree.collect_nodes(
3524 self.0,
3525 [NodeKind::Terminal(TerminalKind::RBrace)],
3526 |[r_brace], visit_ignored| {
3527 Ok(visit(
3528 EndView {
3529 r_brace: RBrace(r_brace),
3530 },
3531 visit_ignored,
3532 ))
3533 },
3534 visit_ignored,
3535 )
3536 }
3537}
3538#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3539pub struct EndView {
3540 pub r_brace: RBrace,
3541}
3542impl EndView {}
3543#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3544pub struct EureHandle(pub(crate) super::tree::CstNodeId);
3545impl NonTerminalHandle for EureHandle {
3546 type View = EureView;
3547 fn node_id(&self) -> CstNodeId {
3548 self.0
3549 }
3550 fn new_with_visit<F: CstFacade, E>(
3551 index: CstNodeId,
3552 tree: &F,
3553 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3554 ) -> Result<Self, CstConstructError<E>> {
3555 tree.collect_nodes(
3556 index,
3557 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
3558 |[index], visit| Ok((Self(index), visit)),
3559 visit_ignored,
3560 )
3561 }
3562 fn kind(&self) -> NonTerminalKind {
3563 NonTerminalKind::Eure
3564 }
3565 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3566 &self,
3567 tree: &F,
3568 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3569 visit_ignored: &'v mut V,
3570 ) -> Result<O, CstConstructError<E>> {
3571 tree.collect_nodes(
3572 self.0,
3573 [
3574 NodeKind::NonTerminal(NonTerminalKind::EureOpt),
3575 NodeKind::NonTerminal(NonTerminalKind::EureList),
3576 NodeKind::NonTerminal(NonTerminalKind::EureList0),
3577 ],
3578 |[eure_opt, eure_bindings, eure_sections], visit_ignored| {
3579 Ok(visit(
3580 EureView {
3581 eure_opt: EureOptHandle(eure_opt),
3582 eure_bindings: EureBindingsHandle(eure_bindings),
3583 eure_sections: EureSectionsHandle(eure_sections),
3584 },
3585 visit_ignored,
3586 ))
3587 },
3588 visit_ignored,
3589 )
3590 }
3591}
3592#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3593pub struct EureView {
3594 pub eure_opt: EureOptHandle,
3595 pub eure_bindings: EureBindingsHandle,
3596 pub eure_sections: EureSectionsHandle,
3597}
3598impl EureView {}
3599#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3600pub struct EureBindingsHandle(pub(crate) super::tree::CstNodeId);
3601impl NonTerminalHandle for EureBindingsHandle {
3602 type View = Option<EureBindingsView>;
3603 fn node_id(&self) -> CstNodeId {
3604 self.0
3605 }
3606 fn new_with_visit<F: CstFacade, E>(
3607 index: CstNodeId,
3608 tree: &F,
3609 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3610 ) -> Result<Self, CstConstructError<E>> {
3611 tree.collect_nodes(
3612 index,
3613 [NodeKind::NonTerminal(NonTerminalKind::EureList)],
3614 |[index], visit| Ok((Self(index), visit)),
3615 visit_ignored,
3616 )
3617 }
3618 fn kind(&self) -> NonTerminalKind {
3619 NonTerminalKind::EureList
3620 }
3621 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3622 &self,
3623 tree: &F,
3624 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3625 visit_ignored: &'v mut V,
3626 ) -> Result<O, CstConstructError<E>> {
3627 if tree.has_no_children(self.0) {
3628 return Ok(visit(None, visit_ignored).0);
3629 }
3630 tree.collect_nodes(
3631 self.0,
3632 [
3633 NodeKind::NonTerminal(NonTerminalKind::Binding),
3634 NodeKind::NonTerminal(NonTerminalKind::EureList),
3635 ],
3636 |[binding, eure_bindings], visit_ignored| {
3637 Ok(visit(
3638 Some(EureBindingsView {
3639 binding: BindingHandle(binding),
3640 eure_bindings: EureBindingsHandle(eure_bindings),
3641 }),
3642 visit_ignored,
3643 ))
3644 },
3645 visit_ignored,
3646 )
3647 }
3648}
3649#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3650pub struct EureBindingsView {
3651 pub binding: BindingHandle,
3652 pub eure_bindings: EureBindingsHandle,
3653}
3654impl<F: CstFacade> RecursiveView<F> for EureBindingsView {
3655 type Item = BindingHandle;
3656 fn get_all_with_visit<E>(
3657 &self,
3658 tree: &F,
3659 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3660 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
3661 let mut items = Vec::new();
3662 let mut current_view = Some(*self);
3663 while let Some(item) = current_view {
3664 let Self { binding, .. } = item;
3665 items.push(binding);
3666 item.eure_bindings.get_view_with_visit(
3667 tree,
3668 |view, visit_ignored| {
3669 current_view = view;
3670 ((), visit_ignored)
3671 },
3672 visit_ignored,
3673 )?;
3674 }
3675 Ok(items)
3676 }
3677}
3678#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3679pub struct EureSectionsHandle(pub(crate) super::tree::CstNodeId);
3680impl NonTerminalHandle for EureSectionsHandle {
3681 type View = Option<EureSectionsView>;
3682 fn node_id(&self) -> CstNodeId {
3683 self.0
3684 }
3685 fn new_with_visit<F: CstFacade, E>(
3686 index: CstNodeId,
3687 tree: &F,
3688 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3689 ) -> Result<Self, CstConstructError<E>> {
3690 tree.collect_nodes(
3691 index,
3692 [NodeKind::NonTerminal(NonTerminalKind::EureList0)],
3693 |[index], visit| Ok((Self(index), visit)),
3694 visit_ignored,
3695 )
3696 }
3697 fn kind(&self) -> NonTerminalKind {
3698 NonTerminalKind::EureList0
3699 }
3700 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3701 &self,
3702 tree: &F,
3703 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3704 visit_ignored: &'v mut V,
3705 ) -> Result<O, CstConstructError<E>> {
3706 if tree.has_no_children(self.0) {
3707 return Ok(visit(None, visit_ignored).0);
3708 }
3709 tree.collect_nodes(
3710 self.0,
3711 [
3712 NodeKind::NonTerminal(NonTerminalKind::Section),
3713 NodeKind::NonTerminal(NonTerminalKind::EureList0),
3714 ],
3715 |[section, eure_sections], visit_ignored| {
3716 Ok(visit(
3717 Some(EureSectionsView {
3718 section: SectionHandle(section),
3719 eure_sections: EureSectionsHandle(eure_sections),
3720 }),
3721 visit_ignored,
3722 ))
3723 },
3724 visit_ignored,
3725 )
3726 }
3727}
3728#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3729pub struct EureSectionsView {
3730 pub section: SectionHandle,
3731 pub eure_sections: EureSectionsHandle,
3732}
3733impl<F: CstFacade> RecursiveView<F> for EureSectionsView {
3734 type Item = SectionHandle;
3735 fn get_all_with_visit<E>(
3736 &self,
3737 tree: &F,
3738 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3739 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
3740 let mut items = Vec::new();
3741 let mut current_view = Some(*self);
3742 while let Some(item) = current_view {
3743 let Self { section, .. } = item;
3744 items.push(section);
3745 item.eure_sections.get_view_with_visit(
3746 tree,
3747 |view, visit_ignored| {
3748 current_view = view;
3749 ((), visit_ignored)
3750 },
3751 visit_ignored,
3752 )?;
3753 }
3754 Ok(items)
3755 }
3756}
3757#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3758pub struct EureOptHandle(pub(crate) super::tree::CstNodeId);
3759impl NonTerminalHandle for EureOptHandle {
3760 type View = Option<TopLevelBindingHandle>;
3761 fn node_id(&self) -> CstNodeId {
3762 self.0
3763 }
3764 fn new_with_visit<F: CstFacade, E>(
3765 index: CstNodeId,
3766 tree: &F,
3767 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3768 ) -> Result<Self, CstConstructError<E>> {
3769 tree.collect_nodes(
3770 index,
3771 [NodeKind::NonTerminal(NonTerminalKind::EureOpt)],
3772 |[index], visit| Ok((Self(index), visit)),
3773 visit_ignored,
3774 )
3775 }
3776 fn kind(&self) -> NonTerminalKind {
3777 NonTerminalKind::EureOpt
3778 }
3779 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3780 &self,
3781 tree: &F,
3782 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3783 visit_ignored: &'v mut V,
3784 ) -> Result<O, CstConstructError<E>> {
3785 if tree.has_no_children(self.0) {
3786 return Ok(visit(None, visit_ignored).0);
3787 }
3788 Ok(visit(
3789 Some(TopLevelBindingHandle::new_with_visit(
3790 self.0,
3791 tree,
3792 visit_ignored,
3793 )?),
3794 visit_ignored,
3795 )
3796 .0)
3797 }
3798}
3799#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3800pub struct ExtHandle(pub(crate) super::tree::CstNodeId);
3801impl NonTerminalHandle for ExtHandle {
3802 type View = ExtView;
3803 fn node_id(&self) -> CstNodeId {
3804 self.0
3805 }
3806 fn new_with_visit<F: CstFacade, E>(
3807 index: CstNodeId,
3808 tree: &F,
3809 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3810 ) -> Result<Self, CstConstructError<E>> {
3811 tree.collect_nodes(
3812 index,
3813 [NodeKind::NonTerminal(NonTerminalKind::Ext)],
3814 |[index], visit| Ok((Self(index), visit)),
3815 visit_ignored,
3816 )
3817 }
3818 fn kind(&self) -> NonTerminalKind {
3819 NonTerminalKind::Ext
3820 }
3821 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3822 &self,
3823 tree: &F,
3824 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3825 visit_ignored: &'v mut V,
3826 ) -> Result<O, CstConstructError<E>> {
3827 tree.collect_nodes(
3828 self.0,
3829 [NodeKind::Terminal(TerminalKind::Dollar)],
3830 |[dollar], visit_ignored| {
3831 Ok(visit(
3832 ExtView {
3833 dollar: Dollar(dollar),
3834 },
3835 visit_ignored,
3836 ))
3837 },
3838 visit_ignored,
3839 )
3840 }
3841}
3842#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3843pub struct ExtView {
3844 pub dollar: Dollar,
3845}
3846impl ExtView {}
3847#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3848pub struct ExtensionNameSpaceHandle(pub(crate) super::tree::CstNodeId);
3849impl NonTerminalHandle for ExtensionNameSpaceHandle {
3850 type View = ExtensionNameSpaceView;
3851 fn node_id(&self) -> CstNodeId {
3852 self.0
3853 }
3854 fn new_with_visit<F: CstFacade, E>(
3855 index: CstNodeId,
3856 tree: &F,
3857 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3858 ) -> Result<Self, CstConstructError<E>> {
3859 tree.collect_nodes(
3860 index,
3861 [NodeKind::NonTerminal(NonTerminalKind::ExtensionNameSpace)],
3862 |[index], visit| Ok((Self(index), visit)),
3863 visit_ignored,
3864 )
3865 }
3866 fn kind(&self) -> NonTerminalKind {
3867 NonTerminalKind::ExtensionNameSpace
3868 }
3869 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3870 &self,
3871 tree: &F,
3872 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3873 visit_ignored: &'v mut V,
3874 ) -> Result<O, CstConstructError<E>> {
3875 tree.collect_nodes(
3876 self.0,
3877 [
3878 NodeKind::NonTerminal(NonTerminalKind::Ext),
3879 NodeKind::NonTerminal(NonTerminalKind::KeyIdent),
3880 ],
3881 |[ext, key_ident], visit_ignored| {
3882 Ok(visit(
3883 ExtensionNameSpaceView {
3884 ext: ExtHandle(ext),
3885 key_ident: KeyIdentHandle(key_ident),
3886 },
3887 visit_ignored,
3888 ))
3889 },
3890 visit_ignored,
3891 )
3892 }
3893}
3894#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3895pub struct ExtensionNameSpaceView {
3896 pub ext: ExtHandle,
3897 pub key_ident: KeyIdentHandle,
3898}
3899impl ExtensionNameSpaceView {}
3900#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3901pub struct FalseHandle(pub(crate) super::tree::CstNodeId);
3902impl NonTerminalHandle for FalseHandle {
3903 type View = FalseView;
3904 fn node_id(&self) -> CstNodeId {
3905 self.0
3906 }
3907 fn new_with_visit<F: CstFacade, E>(
3908 index: CstNodeId,
3909 tree: &F,
3910 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3911 ) -> Result<Self, CstConstructError<E>> {
3912 tree.collect_nodes(
3913 index,
3914 [NodeKind::NonTerminal(NonTerminalKind::False)],
3915 |[index], visit| Ok((Self(index), visit)),
3916 visit_ignored,
3917 )
3918 }
3919 fn kind(&self) -> NonTerminalKind {
3920 NonTerminalKind::False
3921 }
3922 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3923 &self,
3924 tree: &F,
3925 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3926 visit_ignored: &'v mut V,
3927 ) -> Result<O, CstConstructError<E>> {
3928 tree.collect_nodes(
3929 self.0,
3930 [NodeKind::Terminal(TerminalKind::False)],
3931 |[r#false], visit_ignored| {
3932 Ok(visit(
3933 FalseView {
3934 r#false: False(r#false),
3935 },
3936 visit_ignored,
3937 ))
3938 },
3939 visit_ignored,
3940 )
3941 }
3942}
3943#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3944pub struct FalseView {
3945 pub r#false: False,
3946}
3947impl FalseView {}
3948#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
3949pub struct FirstKeyHandle(pub(crate) super::tree::CstNodeId);
3950impl NonTerminalHandle for FirstKeyHandle {
3951 type View = FirstKeyView;
3952 fn node_id(&self) -> CstNodeId {
3953 self.0
3954 }
3955 fn new_with_visit<F: CstFacade, E>(
3956 index: CstNodeId,
3957 tree: &F,
3958 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
3959 ) -> Result<Self, CstConstructError<E>> {
3960 tree.collect_nodes(
3961 index,
3962 [NodeKind::NonTerminal(NonTerminalKind::FirstKey)],
3963 |[index], visit| Ok((Self(index), visit)),
3964 visit_ignored,
3965 )
3966 }
3967 fn kind(&self) -> NonTerminalKind {
3968 NonTerminalKind::FirstKey
3969 }
3970 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
3971 &self,
3972 tree: &F,
3973 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
3974 visit_ignored: &'v mut V,
3975 ) -> Result<O, CstConstructError<E>> {
3976 let mut children = tree.children(self.0);
3977 let Some(child) = children.next() else {
3978 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
3979 };
3980 let Some(child_data) = tree.node_data(child) else {
3981 return Err(ViewConstructionError::NodeIdNotFound { node: child });
3982 };
3983 let variant = match child_data.node_kind() {
3984 NodeKind::NonTerminal(NonTerminalKind::Key) => FirstKeyView::Key(KeyHandle(child)),
3985 NodeKind::NonTerminal(NonTerminalKind::ArrayMarker) => {
3986 FirstKeyView::ArrayMarker(ArrayMarkerHandle(child))
3987 }
3988 _ => {
3989 return Err(ViewConstructionError::UnexpectedNode {
3990 node: child,
3991 data: child_data,
3992 expected_kind: child_data.node_kind(),
3993 });
3994 }
3995 };
3996 let (result, _visit) = visit(variant, visit_ignored);
3997 if let Some(extra_child) = children.next() {
3998 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
3999 }
4000 Ok(result)
4001 }
4002}
4003#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4004pub enum FirstKeyView {
4005 Key(KeyHandle),
4006 ArrayMarker(ArrayMarkerHandle),
4007}
4008impl FirstKeyView {}
4009#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4010pub struct FlatBodyHandle(pub(crate) super::tree::CstNodeId);
4011impl NonTerminalHandle for FlatBodyHandle {
4012 type View = FlatBodyView;
4013 fn node_id(&self) -> CstNodeId {
4014 self.0
4015 }
4016 fn new_with_visit<F: CstFacade, E>(
4017 index: CstNodeId,
4018 tree: &F,
4019 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4020 ) -> Result<Self, CstConstructError<E>> {
4021 tree.collect_nodes(
4022 index,
4023 [NodeKind::NonTerminal(NonTerminalKind::FlatBody)],
4024 |[index], visit| Ok((Self(index), visit)),
4025 visit_ignored,
4026 )
4027 }
4028 fn kind(&self) -> NonTerminalKind {
4029 NonTerminalKind::FlatBody
4030 }
4031 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4032 &self,
4033 tree: &F,
4034 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4035 visit_ignored: &'v mut V,
4036 ) -> Result<O, CstConstructError<E>> {
4037 tree.collect_nodes(
4038 self.0,
4039 [
4040 NodeKind::NonTerminal(NonTerminalKind::SectionHead),
4041 NodeKind::NonTerminal(NonTerminalKind::FlatBodyList),
4042 ],
4043 |[section_head, flat_body_list], visit_ignored| {
4044 Ok(visit(
4045 FlatBodyView {
4046 section_head: SectionHeadHandle(section_head),
4047 flat_body_list: FlatBodyListHandle(flat_body_list),
4048 },
4049 visit_ignored,
4050 ))
4051 },
4052 visit_ignored,
4053 )
4054 }
4055}
4056#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4057pub struct FlatBodyView {
4058 pub section_head: SectionHeadHandle,
4059 pub flat_body_list: FlatBodyListHandle,
4060}
4061impl FlatBodyView {}
4062#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4063pub struct FlatBodyListHandle(pub(crate) super::tree::CstNodeId);
4064impl NonTerminalHandle for FlatBodyListHandle {
4065 type View = Option<FlatBodyListView>;
4066 fn node_id(&self) -> CstNodeId {
4067 self.0
4068 }
4069 fn new_with_visit<F: CstFacade, E>(
4070 index: CstNodeId,
4071 tree: &F,
4072 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4073 ) -> Result<Self, CstConstructError<E>> {
4074 tree.collect_nodes(
4075 index,
4076 [NodeKind::NonTerminal(NonTerminalKind::FlatBodyList)],
4077 |[index], visit| Ok((Self(index), visit)),
4078 visit_ignored,
4079 )
4080 }
4081 fn kind(&self) -> NonTerminalKind {
4082 NonTerminalKind::FlatBodyList
4083 }
4084 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4085 &self,
4086 tree: &F,
4087 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4088 visit_ignored: &'v mut V,
4089 ) -> Result<O, CstConstructError<E>> {
4090 if tree.has_no_children(self.0) {
4091 return Ok(visit(None, visit_ignored).0);
4092 }
4093 tree.collect_nodes(
4094 self.0,
4095 [
4096 NodeKind::NonTerminal(NonTerminalKind::Binding),
4097 NodeKind::NonTerminal(NonTerminalKind::FlatBodyList),
4098 ],
4099 |[binding, flat_body_list], visit_ignored| {
4100 Ok(visit(
4101 Some(FlatBodyListView {
4102 binding: BindingHandle(binding),
4103 flat_body_list: FlatBodyListHandle(flat_body_list),
4104 }),
4105 visit_ignored,
4106 ))
4107 },
4108 visit_ignored,
4109 )
4110 }
4111}
4112#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4113pub struct FlatBodyListView {
4114 pub binding: BindingHandle,
4115 pub flat_body_list: FlatBodyListHandle,
4116}
4117impl<F: CstFacade> RecursiveView<F> for FlatBodyListView {
4118 type Item = BindingHandle;
4119 fn get_all_with_visit<E>(
4120 &self,
4121 tree: &F,
4122 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4123 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
4124 let mut items = Vec::new();
4125 let mut current_view = Some(*self);
4126 while let Some(item) = current_view {
4127 let Self { binding, .. } = item;
4128 items.push(binding);
4129 item.flat_body_list.get_view_with_visit(
4130 tree,
4131 |view, visit_ignored| {
4132 current_view = view;
4133 ((), visit_ignored)
4134 },
4135 visit_ignored,
4136 )?;
4137 }
4138 Ok(items)
4139 }
4140}
4141#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4142pub struct FlatRootBindingHandle(pub(crate) super::tree::CstNodeId);
4143impl NonTerminalHandle for FlatRootBindingHandle {
4144 type View = FlatRootBindingView;
4145 fn node_id(&self) -> CstNodeId {
4146 self.0
4147 }
4148 fn new_with_visit<F: CstFacade, E>(
4149 index: CstNodeId,
4150 tree: &F,
4151 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4152 ) -> Result<Self, CstConstructError<E>> {
4153 tree.collect_nodes(
4154 index,
4155 [NodeKind::NonTerminal(NonTerminalKind::FlatRootBinding)],
4156 |[index], visit| Ok((Self(index), visit)),
4157 visit_ignored,
4158 )
4159 }
4160 fn kind(&self) -> NonTerminalKind {
4161 NonTerminalKind::FlatRootBinding
4162 }
4163 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4164 &self,
4165 tree: &F,
4166 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4167 visit_ignored: &'v mut V,
4168 ) -> Result<O, CstConstructError<E>> {
4169 let mut children = tree.children(self.0);
4170 let Some(child) = children.next() else {
4171 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4172 };
4173 let Some(child_data) = tree.node_data(child) else {
4174 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4175 };
4176 let variant = match child_data.node_kind() {
4177 NodeKind::NonTerminal(NonTerminalKind::ValueBinding) => {
4178 FlatRootBindingView::ValueBinding(ValueBindingHandle(child))
4179 }
4180 NodeKind::NonTerminal(NonTerminalKind::TextBinding) => {
4181 FlatRootBindingView::TextBinding(TextBindingHandle(child))
4182 }
4183 _ => {
4184 return Err(ViewConstructionError::UnexpectedNode {
4185 node: child,
4186 data: child_data,
4187 expected_kind: child_data.node_kind(),
4188 });
4189 }
4190 };
4191 let (result, _visit) = visit(variant, visit_ignored);
4192 if let Some(extra_child) = children.next() {
4193 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4194 }
4195 Ok(result)
4196 }
4197}
4198#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4199pub enum FlatRootBindingView {
4200 ValueBinding(ValueBindingHandle),
4201 TextBinding(TextBindingHandle),
4202}
4203impl FlatRootBindingView {}
4204#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4205pub struct FloatHandle(pub(crate) super::tree::CstNodeId);
4206impl NonTerminalHandle for FloatHandle {
4207 type View = FloatView;
4208 fn node_id(&self) -> CstNodeId {
4209 self.0
4210 }
4211 fn new_with_visit<F: CstFacade, E>(
4212 index: CstNodeId,
4213 tree: &F,
4214 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4215 ) -> Result<Self, CstConstructError<E>> {
4216 tree.collect_nodes(
4217 index,
4218 [NodeKind::NonTerminal(NonTerminalKind::Float)],
4219 |[index], visit| Ok((Self(index), visit)),
4220 visit_ignored,
4221 )
4222 }
4223 fn kind(&self) -> NonTerminalKind {
4224 NonTerminalKind::Float
4225 }
4226 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4227 &self,
4228 tree: &F,
4229 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4230 visit_ignored: &'v mut V,
4231 ) -> Result<O, CstConstructError<E>> {
4232 tree.collect_nodes(
4233 self.0,
4234 [NodeKind::Terminal(TerminalKind::Float)],
4235 |[float], visit_ignored| {
4236 Ok(visit(
4237 FloatView {
4238 float: Float(float),
4239 },
4240 visit_ignored,
4241 ))
4242 },
4243 visit_ignored,
4244 )
4245 }
4246}
4247#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4248pub struct FloatView {
4249 pub float: Float,
4250}
4251impl FloatView {}
4252#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4253pub struct GrammarNewlineHandle(pub(crate) super::tree::CstNodeId);
4254impl NonTerminalHandle for GrammarNewlineHandle {
4255 type View = GrammarNewlineView;
4256 fn node_id(&self) -> CstNodeId {
4257 self.0
4258 }
4259 fn new_with_visit<F: CstFacade, E>(
4260 index: CstNodeId,
4261 tree: &F,
4262 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4263 ) -> Result<Self, CstConstructError<E>> {
4264 tree.collect_nodes(
4265 index,
4266 [NodeKind::NonTerminal(NonTerminalKind::GrammarNewline)],
4267 |[index], visit| Ok((Self(index), visit)),
4268 visit_ignored,
4269 )
4270 }
4271 fn kind(&self) -> NonTerminalKind {
4272 NonTerminalKind::GrammarNewline
4273 }
4274 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4275 &self,
4276 tree: &F,
4277 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4278 visit_ignored: &'v mut V,
4279 ) -> Result<O, CstConstructError<E>> {
4280 tree.collect_nodes(
4281 self.0,
4282 [NodeKind::Terminal(TerminalKind::GrammarNewline)],
4283 |[grammar_newline], visit_ignored| {
4284 Ok(visit(
4285 GrammarNewlineView {
4286 grammar_newline: GrammarNewline(grammar_newline),
4287 },
4288 visit_ignored,
4289 ))
4290 },
4291 visit_ignored,
4292 )
4293 }
4294}
4295#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4296pub struct GrammarNewlineView {
4297 pub grammar_newline: GrammarNewline,
4298}
4299impl GrammarNewlineView {}
4300#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4301pub struct HoleHandle(pub(crate) super::tree::CstNodeId);
4302impl NonTerminalHandle for HoleHandle {
4303 type View = HoleView;
4304 fn node_id(&self) -> CstNodeId {
4305 self.0
4306 }
4307 fn new_with_visit<F: CstFacade, E>(
4308 index: CstNodeId,
4309 tree: &F,
4310 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4311 ) -> Result<Self, CstConstructError<E>> {
4312 tree.collect_nodes(
4313 index,
4314 [NodeKind::NonTerminal(NonTerminalKind::Hole)],
4315 |[index], visit| Ok((Self(index), visit)),
4316 visit_ignored,
4317 )
4318 }
4319 fn kind(&self) -> NonTerminalKind {
4320 NonTerminalKind::Hole
4321 }
4322 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4323 &self,
4324 tree: &F,
4325 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4326 visit_ignored: &'v mut V,
4327 ) -> Result<O, CstConstructError<E>> {
4328 tree.collect_nodes(
4329 self.0,
4330 [NodeKind::Terminal(TerminalKind::Hole)],
4331 |[hole], visit_ignored| Ok(visit(HoleView { hole: Hole(hole) }, visit_ignored)),
4332 visit_ignored,
4333 )
4334 }
4335}
4336#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4337pub struct HoleView {
4338 pub hole: Hole,
4339}
4340impl HoleView {}
4341#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4342pub struct IdentHandle(pub(crate) super::tree::CstNodeId);
4343impl NonTerminalHandle for IdentHandle {
4344 type View = IdentView;
4345 fn node_id(&self) -> CstNodeId {
4346 self.0
4347 }
4348 fn new_with_visit<F: CstFacade, E>(
4349 index: CstNodeId,
4350 tree: &F,
4351 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4352 ) -> Result<Self, CstConstructError<E>> {
4353 tree.collect_nodes(
4354 index,
4355 [NodeKind::NonTerminal(NonTerminalKind::Ident)],
4356 |[index], visit| Ok((Self(index), visit)),
4357 visit_ignored,
4358 )
4359 }
4360 fn kind(&self) -> NonTerminalKind {
4361 NonTerminalKind::Ident
4362 }
4363 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4364 &self,
4365 tree: &F,
4366 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4367 visit_ignored: &'v mut V,
4368 ) -> Result<O, CstConstructError<E>> {
4369 tree.collect_nodes(
4370 self.0,
4371 [NodeKind::Terminal(TerminalKind::Ident)],
4372 |[ident], visit_ignored| {
4373 Ok(visit(
4374 IdentView {
4375 ident: Ident(ident),
4376 },
4377 visit_ignored,
4378 ))
4379 },
4380 visit_ignored,
4381 )
4382 }
4383}
4384#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4385pub struct IdentView {
4386 pub ident: Ident,
4387}
4388impl IdentView {}
4389#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4390pub struct InfHandle(pub(crate) super::tree::CstNodeId);
4391impl NonTerminalHandle for InfHandle {
4392 type View = InfView;
4393 fn node_id(&self) -> CstNodeId {
4394 self.0
4395 }
4396 fn new_with_visit<F: CstFacade, E>(
4397 index: CstNodeId,
4398 tree: &F,
4399 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4400 ) -> Result<Self, CstConstructError<E>> {
4401 tree.collect_nodes(
4402 index,
4403 [NodeKind::NonTerminal(NonTerminalKind::Inf)],
4404 |[index], visit| Ok((Self(index), visit)),
4405 visit_ignored,
4406 )
4407 }
4408 fn kind(&self) -> NonTerminalKind {
4409 NonTerminalKind::Inf
4410 }
4411 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4412 &self,
4413 tree: &F,
4414 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4415 visit_ignored: &'v mut V,
4416 ) -> Result<O, CstConstructError<E>> {
4417 tree.collect_nodes(
4418 self.0,
4419 [NodeKind::Terminal(TerminalKind::Inf)],
4420 |[inf], visit_ignored| Ok(visit(InfView { inf: Inf(inf) }, visit_ignored)),
4421 visit_ignored,
4422 )
4423 }
4424}
4425#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4426pub struct InfView {
4427 pub inf: Inf,
4428}
4429impl InfView {}
4430#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4431pub struct InlineCodeHandle(pub(crate) super::tree::CstNodeId);
4432impl NonTerminalHandle for InlineCodeHandle {
4433 type View = InlineCodeView;
4434 fn node_id(&self) -> CstNodeId {
4435 self.0
4436 }
4437 fn new_with_visit<F: CstFacade, E>(
4438 index: CstNodeId,
4439 tree: &F,
4440 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4441 ) -> Result<Self, CstConstructError<E>> {
4442 tree.collect_nodes(
4443 index,
4444 [NodeKind::NonTerminal(NonTerminalKind::InlineCode)],
4445 |[index], visit| Ok((Self(index), visit)),
4446 visit_ignored,
4447 )
4448 }
4449 fn kind(&self) -> NonTerminalKind {
4450 NonTerminalKind::InlineCode
4451 }
4452 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4453 &self,
4454 tree: &F,
4455 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4456 visit_ignored: &'v mut V,
4457 ) -> Result<O, CstConstructError<E>> {
4458 let mut children = tree.children(self.0);
4459 let Some(child) = children.next() else {
4460 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4461 };
4462 let Some(child_data) = tree.node_data(child) else {
4463 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4464 };
4465 let variant = match child_data.node_kind() {
4466 NodeKind::NonTerminal(NonTerminalKind::DelimCode) => {
4467 InlineCodeView::DelimCode(DelimCodeHandle(child))
4468 }
4469 NodeKind::NonTerminal(NonTerminalKind::InlineCode1) => {
4470 InlineCodeView::InlineCode1(InlineCode1Handle(child))
4471 }
4472 _ => {
4473 return Err(ViewConstructionError::UnexpectedNode {
4474 node: child,
4475 data: child_data,
4476 expected_kind: child_data.node_kind(),
4477 });
4478 }
4479 };
4480 let (result, _visit) = visit(variant, visit_ignored);
4481 if let Some(extra_child) = children.next() {
4482 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4483 }
4484 Ok(result)
4485 }
4486}
4487#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4488pub enum InlineCodeView {
4489 DelimCode(DelimCodeHandle),
4490 InlineCode1(InlineCode1Handle),
4491}
4492impl InlineCodeView {}
4493#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4494pub struct InlineCode1Handle(pub(crate) super::tree::CstNodeId);
4495impl NonTerminalHandle for InlineCode1Handle {
4496 type View = InlineCode1View;
4497 fn node_id(&self) -> CstNodeId {
4498 self.0
4499 }
4500 fn new_with_visit<F: CstFacade, E>(
4501 index: CstNodeId,
4502 tree: &F,
4503 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4504 ) -> Result<Self, CstConstructError<E>> {
4505 tree.collect_nodes(
4506 index,
4507 [NodeKind::NonTerminal(NonTerminalKind::InlineCode1)],
4508 |[index], visit| Ok((Self(index), visit)),
4509 visit_ignored,
4510 )
4511 }
4512 fn kind(&self) -> NonTerminalKind {
4513 NonTerminalKind::InlineCode1
4514 }
4515 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4516 &self,
4517 tree: &F,
4518 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4519 visit_ignored: &'v mut V,
4520 ) -> Result<O, CstConstructError<E>> {
4521 tree.collect_nodes(
4522 self.0,
4523 [NodeKind::Terminal(TerminalKind::InlineCode1)],
4524 |[inline_code_1], visit_ignored| {
4525 Ok(visit(
4526 InlineCode1View {
4527 inline_code_1: InlineCode1(inline_code_1),
4528 },
4529 visit_ignored,
4530 ))
4531 },
4532 visit_ignored,
4533 )
4534 }
4535}
4536#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4537pub struct InlineCode1View {
4538 pub inline_code_1: InlineCode1,
4539}
4540impl InlineCode1View {}
4541#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4542pub struct IntegerHandle(pub(crate) super::tree::CstNodeId);
4543impl NonTerminalHandle for IntegerHandle {
4544 type View = IntegerView;
4545 fn node_id(&self) -> CstNodeId {
4546 self.0
4547 }
4548 fn new_with_visit<F: CstFacade, E>(
4549 index: CstNodeId,
4550 tree: &F,
4551 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4552 ) -> Result<Self, CstConstructError<E>> {
4553 tree.collect_nodes(
4554 index,
4555 [NodeKind::NonTerminal(NonTerminalKind::Integer)],
4556 |[index], visit| Ok((Self(index), visit)),
4557 visit_ignored,
4558 )
4559 }
4560 fn kind(&self) -> NonTerminalKind {
4561 NonTerminalKind::Integer
4562 }
4563 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4564 &self,
4565 tree: &F,
4566 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4567 visit_ignored: &'v mut V,
4568 ) -> Result<O, CstConstructError<E>> {
4569 tree.collect_nodes(
4570 self.0,
4571 [NodeKind::Terminal(TerminalKind::Integer)],
4572 |[integer], visit_ignored| {
4573 Ok(visit(
4574 IntegerView {
4575 integer: Integer(integer),
4576 },
4577 visit_ignored,
4578 ))
4579 },
4580 visit_ignored,
4581 )
4582 }
4583}
4584#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4585pub struct IntegerView {
4586 pub integer: Integer,
4587}
4588impl IntegerView {}
4589#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4590pub struct KeyHandle(pub(crate) super::tree::CstNodeId);
4591impl NonTerminalHandle for KeyHandle {
4592 type View = KeyView;
4593 fn node_id(&self) -> CstNodeId {
4594 self.0
4595 }
4596 fn new_with_visit<F: CstFacade, E>(
4597 index: CstNodeId,
4598 tree: &F,
4599 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4600 ) -> Result<Self, CstConstructError<E>> {
4601 tree.collect_nodes(
4602 index,
4603 [NodeKind::NonTerminal(NonTerminalKind::Key)],
4604 |[index], visit| Ok((Self(index), visit)),
4605 visit_ignored,
4606 )
4607 }
4608 fn kind(&self) -> NonTerminalKind {
4609 NonTerminalKind::Key
4610 }
4611 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4612 &self,
4613 tree: &F,
4614 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4615 visit_ignored: &'v mut V,
4616 ) -> Result<O, CstConstructError<E>> {
4617 let mut children = tree.children(self.0);
4618 let Some(child) = children.next() else {
4619 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4620 };
4621 let Some(child_data) = tree.node_data(child) else {
4622 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4623 };
4624 let variant = match child_data.node_kind() {
4625 NodeKind::NonTerminal(NonTerminalKind::KeyIdent) => {
4626 KeyView::KeyIdent(KeyIdentHandle(child))
4627 }
4628 NodeKind::NonTerminal(NonTerminalKind::ExtensionNameSpace) => {
4629 KeyView::ExtensionNameSpace(ExtensionNameSpaceHandle(child))
4630 }
4631 NodeKind::NonTerminal(NonTerminalKind::String) => KeyView::String(StringHandle(child)),
4632 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
4633 KeyView::Integer(IntegerHandle(child))
4634 }
4635 NodeKind::NonTerminal(NonTerminalKind::Float) => KeyView::Float(FloatHandle(child)),
4636 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
4637 KeyView::KeyTuple(KeyTupleHandle(child))
4638 }
4639 NodeKind::NonTerminal(NonTerminalKind::TupleIndex) => {
4640 KeyView::TupleIndex(TupleIndexHandle(child))
4641 }
4642 _ => {
4643 return Err(ViewConstructionError::UnexpectedNode {
4644 node: child,
4645 data: child_data,
4646 expected_kind: child_data.node_kind(),
4647 });
4648 }
4649 };
4650 let (result, _visit) = visit(variant, visit_ignored);
4651 if let Some(extra_child) = children.next() {
4652 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4653 }
4654 Ok(result)
4655 }
4656}
4657#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4658pub enum KeyView {
4659 KeyIdent(KeyIdentHandle),
4660 ExtensionNameSpace(ExtensionNameSpaceHandle),
4661 String(StringHandle),
4662 Integer(IntegerHandle),
4663 Float(FloatHandle),
4664 KeyTuple(KeyTupleHandle),
4665 TupleIndex(TupleIndexHandle),
4666}
4667impl KeyView {}
4668#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4669pub struct KeyIdentHandle(pub(crate) super::tree::CstNodeId);
4670impl NonTerminalHandle for KeyIdentHandle {
4671 type View = KeyIdentView;
4672 fn node_id(&self) -> CstNodeId {
4673 self.0
4674 }
4675 fn new_with_visit<F: CstFacade, E>(
4676 index: CstNodeId,
4677 tree: &F,
4678 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4679 ) -> Result<Self, CstConstructError<E>> {
4680 tree.collect_nodes(
4681 index,
4682 [NodeKind::NonTerminal(NonTerminalKind::KeyIdent)],
4683 |[index], visit| Ok((Self(index), visit)),
4684 visit_ignored,
4685 )
4686 }
4687 fn kind(&self) -> NonTerminalKind {
4688 NonTerminalKind::KeyIdent
4689 }
4690 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4691 &self,
4692 tree: &F,
4693 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4694 visit_ignored: &'v mut V,
4695 ) -> Result<O, CstConstructError<E>> {
4696 let mut children = tree.children(self.0);
4697 let Some(child) = children.next() else {
4698 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4699 };
4700 let Some(child_data) = tree.node_data(child) else {
4701 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4702 };
4703 let variant = match child_data.node_kind() {
4704 NodeKind::NonTerminal(NonTerminalKind::Ident) => {
4705 KeyIdentView::Ident(IdentHandle(child))
4706 }
4707 NodeKind::NonTerminal(NonTerminalKind::True) => KeyIdentView::True(TrueHandle(child)),
4708 NodeKind::NonTerminal(NonTerminalKind::False) => {
4709 KeyIdentView::False(FalseHandle(child))
4710 }
4711 NodeKind::NonTerminal(NonTerminalKind::Null) => KeyIdentView::Null(NullHandle(child)),
4712 _ => {
4713 return Err(ViewConstructionError::UnexpectedNode {
4714 node: child,
4715 data: child_data,
4716 expected_kind: child_data.node_kind(),
4717 });
4718 }
4719 };
4720 let (result, _visit) = visit(variant, visit_ignored);
4721 if let Some(extra_child) = children.next() {
4722 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4723 }
4724 Ok(result)
4725 }
4726}
4727#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4728pub enum KeyIdentView {
4729 Ident(IdentHandle),
4730 True(TrueHandle),
4731 False(FalseHandle),
4732 Null(NullHandle),
4733}
4734impl KeyIdentView {}
4735#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4736pub struct KeyTailHandle(pub(crate) super::tree::CstNodeId);
4737impl NonTerminalHandle for KeyTailHandle {
4738 type View = KeyTailView;
4739 fn node_id(&self) -> CstNodeId {
4740 self.0
4741 }
4742 fn new_with_visit<F: CstFacade, E>(
4743 index: CstNodeId,
4744 tree: &F,
4745 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4746 ) -> Result<Self, CstConstructError<E>> {
4747 tree.collect_nodes(
4748 index,
4749 [NodeKind::NonTerminal(NonTerminalKind::KeyTail)],
4750 |[index], visit| Ok((Self(index), visit)),
4751 visit_ignored,
4752 )
4753 }
4754 fn kind(&self) -> NonTerminalKind {
4755 NonTerminalKind::KeyTail
4756 }
4757 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4758 &self,
4759 tree: &F,
4760 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4761 visit_ignored: &'v mut V,
4762 ) -> Result<O, CstConstructError<E>> {
4763 let mut children = tree.children(self.0);
4764 let Some(child) = children.next() else {
4765 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4766 };
4767 let Some(child_data) = tree.node_data(child) else {
4768 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4769 };
4770 let variant = match child_data.node_kind() {
4771 NodeKind::NonTerminal(NonTerminalKind::DotKey) => {
4772 KeyTailView::DotKey(DotKeyHandle(child))
4773 }
4774 NodeKind::NonTerminal(NonTerminalKind::ArrayMarker) => {
4775 KeyTailView::ArrayMarker(ArrayMarkerHandle(child))
4776 }
4777 _ => {
4778 return Err(ViewConstructionError::UnexpectedNode {
4779 node: child,
4780 data: child_data,
4781 expected_kind: child_data.node_kind(),
4782 });
4783 }
4784 };
4785 let (result, _visit) = visit(variant, visit_ignored);
4786 if let Some(extra_child) = children.next() {
4787 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4788 }
4789 Ok(result)
4790 }
4791}
4792#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4793pub enum KeyTailView {
4794 DotKey(DotKeyHandle),
4795 ArrayMarker(ArrayMarkerHandle),
4796}
4797impl KeyTailView {}
4798#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4799pub struct KeyTupleHandle(pub(crate) super::tree::CstNodeId);
4800impl NonTerminalHandle for KeyTupleHandle {
4801 type View = KeyTupleView;
4802 fn node_id(&self) -> CstNodeId {
4803 self.0
4804 }
4805 fn new_with_visit<F: CstFacade, E>(
4806 index: CstNodeId,
4807 tree: &F,
4808 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4809 ) -> Result<Self, CstConstructError<E>> {
4810 tree.collect_nodes(
4811 index,
4812 [NodeKind::NonTerminal(NonTerminalKind::KeyTuple)],
4813 |[index], visit| Ok((Self(index), visit)),
4814 visit_ignored,
4815 )
4816 }
4817 fn kind(&self) -> NonTerminalKind {
4818 NonTerminalKind::KeyTuple
4819 }
4820 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4821 &self,
4822 tree: &F,
4823 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4824 visit_ignored: &'v mut V,
4825 ) -> Result<O, CstConstructError<E>> {
4826 tree.collect_nodes(
4827 self.0,
4828 [
4829 NodeKind::NonTerminal(NonTerminalKind::LParen),
4830 NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt),
4831 NodeKind::NonTerminal(NonTerminalKind::RParen),
4832 ],
4833 |[l_paren, key_tuple_opt, r_paren], visit_ignored| {
4834 Ok(visit(
4835 KeyTupleView {
4836 l_paren: LParenHandle(l_paren),
4837 key_tuple_opt: KeyTupleOptHandle(key_tuple_opt),
4838 r_paren: RParenHandle(r_paren),
4839 },
4840 visit_ignored,
4841 ))
4842 },
4843 visit_ignored,
4844 )
4845 }
4846}
4847#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4848pub struct KeyTupleView {
4849 pub l_paren: LParenHandle,
4850 pub key_tuple_opt: KeyTupleOptHandle,
4851 pub r_paren: RParenHandle,
4852}
4853impl KeyTupleView {}
4854#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4855pub struct KeyTupleElementsHandle(pub(crate) super::tree::CstNodeId);
4856impl NonTerminalHandle for KeyTupleElementsHandle {
4857 type View = KeyTupleElementsView;
4858 fn node_id(&self) -> CstNodeId {
4859 self.0
4860 }
4861 fn new_with_visit<F: CstFacade, E>(
4862 index: CstNodeId,
4863 tree: &F,
4864 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4865 ) -> Result<Self, CstConstructError<E>> {
4866 tree.collect_nodes(
4867 index,
4868 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElements)],
4869 |[index], visit| Ok((Self(index), visit)),
4870 visit_ignored,
4871 )
4872 }
4873 fn kind(&self) -> NonTerminalKind {
4874 NonTerminalKind::KeyTupleElements
4875 }
4876 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4877 &self,
4878 tree: &F,
4879 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4880 visit_ignored: &'v mut V,
4881 ) -> Result<O, CstConstructError<E>> {
4882 tree.collect_nodes(
4883 self.0,
4884 [
4885 NodeKind::NonTerminal(NonTerminalKind::KeyValue),
4886 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt),
4887 ],
4888 |[key_value, key_tuple_elements_opt], visit_ignored| {
4889 Ok(visit(
4890 KeyTupleElementsView {
4891 key_value: KeyValueHandle(key_value),
4892 key_tuple_elements_opt: KeyTupleElementsOptHandle(key_tuple_elements_opt),
4893 },
4894 visit_ignored,
4895 ))
4896 },
4897 visit_ignored,
4898 )
4899 }
4900}
4901#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4902pub struct KeyTupleElementsView {
4903 pub key_value: KeyValueHandle,
4904 pub key_tuple_elements_opt: KeyTupleElementsOptHandle,
4905}
4906impl KeyTupleElementsView {}
4907#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4908pub struct KeyTupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
4909impl NonTerminalHandle for KeyTupleElementsOptHandle {
4910 type View = Option<KeyTupleElementsTailHandle>;
4911 fn node_id(&self) -> CstNodeId {
4912 self.0
4913 }
4914 fn new_with_visit<F: CstFacade, E>(
4915 index: CstNodeId,
4916 tree: &F,
4917 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4918 ) -> Result<Self, CstConstructError<E>> {
4919 tree.collect_nodes(
4920 index,
4921 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt)],
4922 |[index], visit| Ok((Self(index), visit)),
4923 visit_ignored,
4924 )
4925 }
4926 fn kind(&self) -> NonTerminalKind {
4927 NonTerminalKind::KeyTupleElementsOpt
4928 }
4929 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4930 &self,
4931 tree: &F,
4932 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4933 visit_ignored: &'v mut V,
4934 ) -> Result<O, CstConstructError<E>> {
4935 if tree.has_no_children(self.0) {
4936 return Ok(visit(None, visit_ignored).0);
4937 }
4938 Ok(visit(
4939 Some(KeyTupleElementsTailHandle::new_with_visit(
4940 self.0,
4941 tree,
4942 visit_ignored,
4943 )?),
4944 visit_ignored,
4945 )
4946 .0)
4947 }
4948}
4949#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4950pub struct KeyTupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
4951impl NonTerminalHandle for KeyTupleElementsTailHandle {
4952 type View = KeyTupleElementsTailView;
4953 fn node_id(&self) -> CstNodeId {
4954 self.0
4955 }
4956 fn new_with_visit<F: CstFacade, E>(
4957 index: CstNodeId,
4958 tree: &F,
4959 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4960 ) -> Result<Self, CstConstructError<E>> {
4961 tree.collect_nodes(
4962 index,
4963 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTail)],
4964 |[index], visit| Ok((Self(index), visit)),
4965 visit_ignored,
4966 )
4967 }
4968 fn kind(&self) -> NonTerminalKind {
4969 NonTerminalKind::KeyTupleElementsTail
4970 }
4971 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4972 &self,
4973 tree: &F,
4974 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4975 visit_ignored: &'v mut V,
4976 ) -> Result<O, CstConstructError<E>> {
4977 tree.collect_nodes(
4978 self.0,
4979 [
4980 NodeKind::NonTerminal(NonTerminalKind::Comma),
4981 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTailOpt),
4982 ],
4983 |[comma, key_tuple_elements_tail_opt], visit_ignored| {
4984 Ok(visit(
4985 KeyTupleElementsTailView {
4986 comma: CommaHandle(comma),
4987 key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle(
4988 key_tuple_elements_tail_opt,
4989 ),
4990 },
4991 visit_ignored,
4992 ))
4993 },
4994 visit_ignored,
4995 )
4996 }
4997}
4998#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4999pub struct KeyTupleElementsTailView {
5000 pub comma: CommaHandle,
5001 pub key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle,
5002}
5003impl KeyTupleElementsTailView {}
5004#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5005pub struct KeyTupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
5006impl NonTerminalHandle for KeyTupleElementsTailOptHandle {
5007 type View = Option<KeyTupleElementsHandle>;
5008 fn node_id(&self) -> CstNodeId {
5009 self.0
5010 }
5011 fn new_with_visit<F: CstFacade, E>(
5012 index: CstNodeId,
5013 tree: &F,
5014 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5015 ) -> Result<Self, CstConstructError<E>> {
5016 tree.collect_nodes(
5017 index,
5018 [NodeKind::NonTerminal(
5019 NonTerminalKind::KeyTupleElementsTailOpt,
5020 )],
5021 |[index], visit| Ok((Self(index), visit)),
5022 visit_ignored,
5023 )
5024 }
5025 fn kind(&self) -> NonTerminalKind {
5026 NonTerminalKind::KeyTupleElementsTailOpt
5027 }
5028 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5029 &self,
5030 tree: &F,
5031 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5032 visit_ignored: &'v mut V,
5033 ) -> Result<O, CstConstructError<E>> {
5034 if tree.has_no_children(self.0) {
5035 return Ok(visit(None, visit_ignored).0);
5036 }
5037 Ok(visit(
5038 Some(KeyTupleElementsHandle::new_with_visit(
5039 self.0,
5040 tree,
5041 visit_ignored,
5042 )?),
5043 visit_ignored,
5044 )
5045 .0)
5046 }
5047}
5048#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5049pub struct KeyTupleOptHandle(pub(crate) super::tree::CstNodeId);
5050impl NonTerminalHandle for KeyTupleOptHandle {
5051 type View = Option<KeyTupleElementsHandle>;
5052 fn node_id(&self) -> CstNodeId {
5053 self.0
5054 }
5055 fn new_with_visit<F: CstFacade, E>(
5056 index: CstNodeId,
5057 tree: &F,
5058 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5059 ) -> Result<Self, CstConstructError<E>> {
5060 tree.collect_nodes(
5061 index,
5062 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt)],
5063 |[index], visit| Ok((Self(index), visit)),
5064 visit_ignored,
5065 )
5066 }
5067 fn kind(&self) -> NonTerminalKind {
5068 NonTerminalKind::KeyTupleOpt
5069 }
5070 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5071 &self,
5072 tree: &F,
5073 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5074 visit_ignored: &'v mut V,
5075 ) -> Result<O, CstConstructError<E>> {
5076 if tree.has_no_children(self.0) {
5077 return Ok(visit(None, visit_ignored).0);
5078 }
5079 Ok(visit(
5080 Some(KeyTupleElementsHandle::new_with_visit(
5081 self.0,
5082 tree,
5083 visit_ignored,
5084 )?),
5085 visit_ignored,
5086 )
5087 .0)
5088 }
5089}
5090#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5091pub struct KeyValueHandle(pub(crate) super::tree::CstNodeId);
5092impl NonTerminalHandle for KeyValueHandle {
5093 type View = KeyValueView;
5094 fn node_id(&self) -> CstNodeId {
5095 self.0
5096 }
5097 fn new_with_visit<F: CstFacade, E>(
5098 index: CstNodeId,
5099 tree: &F,
5100 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5101 ) -> Result<Self, CstConstructError<E>> {
5102 tree.collect_nodes(
5103 index,
5104 [NodeKind::NonTerminal(NonTerminalKind::KeyValue)],
5105 |[index], visit| Ok((Self(index), visit)),
5106 visit_ignored,
5107 )
5108 }
5109 fn kind(&self) -> NonTerminalKind {
5110 NonTerminalKind::KeyValue
5111 }
5112 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5113 &self,
5114 tree: &F,
5115 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5116 visit_ignored: &'v mut V,
5117 ) -> Result<O, CstConstructError<E>> {
5118 let mut children = tree.children(self.0);
5119 let Some(child) = children.next() else {
5120 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5121 };
5122 let Some(child_data) = tree.node_data(child) else {
5123 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5124 };
5125 let variant = match child_data.node_kind() {
5126 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
5127 KeyValueView::Integer(IntegerHandle(child))
5128 }
5129 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
5130 KeyValueView::Boolean(BooleanHandle(child))
5131 }
5132 NodeKind::NonTerminal(NonTerminalKind::Str) => KeyValueView::Str(StrHandle(child)),
5133 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
5134 KeyValueView::KeyTuple(KeyTupleHandle(child))
5135 }
5136 _ => {
5137 return Err(ViewConstructionError::UnexpectedNode {
5138 node: child,
5139 data: child_data,
5140 expected_kind: child_data.node_kind(),
5141 });
5142 }
5143 };
5144 let (result, _visit) = visit(variant, visit_ignored);
5145 if let Some(extra_child) = children.next() {
5146 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5147 }
5148 Ok(result)
5149 }
5150}
5151#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5152pub enum KeyValueView {
5153 Integer(IntegerHandle),
5154 Boolean(BooleanHandle),
5155 Str(StrHandle),
5156 KeyTuple(KeyTupleHandle),
5157}
5158impl KeyValueView {}
5159#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5160pub struct KeysHandle(pub(crate) super::tree::CstNodeId);
5161impl NonTerminalHandle for KeysHandle {
5162 type View = KeysView;
5163 fn node_id(&self) -> CstNodeId {
5164 self.0
5165 }
5166 fn new_with_visit<F: CstFacade, E>(
5167 index: CstNodeId,
5168 tree: &F,
5169 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5170 ) -> Result<Self, CstConstructError<E>> {
5171 tree.collect_nodes(
5172 index,
5173 [NodeKind::NonTerminal(NonTerminalKind::Keys)],
5174 |[index], visit| Ok((Self(index), visit)),
5175 visit_ignored,
5176 )
5177 }
5178 fn kind(&self) -> NonTerminalKind {
5179 NonTerminalKind::Keys
5180 }
5181 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5182 &self,
5183 tree: &F,
5184 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5185 visit_ignored: &'v mut V,
5186 ) -> Result<O, CstConstructError<E>> {
5187 tree.collect_nodes(
5188 self.0,
5189 [
5190 NodeKind::NonTerminal(NonTerminalKind::FirstKey),
5191 NodeKind::NonTerminal(NonTerminalKind::KeysList),
5192 ],
5193 |[first_key, keys_list], visit_ignored| {
5194 Ok(visit(
5195 KeysView {
5196 first_key: FirstKeyHandle(first_key),
5197 keys_list: KeysListHandle(keys_list),
5198 },
5199 visit_ignored,
5200 ))
5201 },
5202 visit_ignored,
5203 )
5204 }
5205}
5206#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5207pub struct KeysView {
5208 pub first_key: FirstKeyHandle,
5209 pub keys_list: KeysListHandle,
5210}
5211impl KeysView {}
5212#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5213pub struct KeysListHandle(pub(crate) super::tree::CstNodeId);
5214impl NonTerminalHandle for KeysListHandle {
5215 type View = Option<KeysListView>;
5216 fn node_id(&self) -> CstNodeId {
5217 self.0
5218 }
5219 fn new_with_visit<F: CstFacade, E>(
5220 index: CstNodeId,
5221 tree: &F,
5222 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5223 ) -> Result<Self, CstConstructError<E>> {
5224 tree.collect_nodes(
5225 index,
5226 [NodeKind::NonTerminal(NonTerminalKind::KeysList)],
5227 |[index], visit| Ok((Self(index), visit)),
5228 visit_ignored,
5229 )
5230 }
5231 fn kind(&self) -> NonTerminalKind {
5232 NonTerminalKind::KeysList
5233 }
5234 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5235 &self,
5236 tree: &F,
5237 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5238 visit_ignored: &'v mut V,
5239 ) -> Result<O, CstConstructError<E>> {
5240 if tree.has_no_children(self.0) {
5241 return Ok(visit(None, visit_ignored).0);
5242 }
5243 tree.collect_nodes(
5244 self.0,
5245 [
5246 NodeKind::NonTerminal(NonTerminalKind::KeyTail),
5247 NodeKind::NonTerminal(NonTerminalKind::KeysList),
5248 ],
5249 |[key_tail, keys_list], visit_ignored| {
5250 Ok(visit(
5251 Some(KeysListView {
5252 key_tail: KeyTailHandle(key_tail),
5253 keys_list: KeysListHandle(keys_list),
5254 }),
5255 visit_ignored,
5256 ))
5257 },
5258 visit_ignored,
5259 )
5260 }
5261}
5262#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5263pub struct KeysListView {
5264 pub key_tail: KeyTailHandle,
5265 pub keys_list: KeysListHandle,
5266}
5267impl<F: CstFacade> RecursiveView<F> for KeysListView {
5268 type Item = KeyTailHandle;
5269 fn get_all_with_visit<E>(
5270 &self,
5271 tree: &F,
5272 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5273 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5274 let mut items = Vec::new();
5275 let mut current_view = Some(*self);
5276 while let Some(item) = current_view {
5277 let Self { key_tail, .. } = item;
5278 items.push(key_tail);
5279 item.keys_list.get_view_with_visit(
5280 tree,
5281 |view, visit_ignored| {
5282 current_view = view;
5283 ((), visit_ignored)
5284 },
5285 visit_ignored,
5286 )?;
5287 }
5288 Ok(items)
5289 }
5290}
5291#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5292pub struct LParenHandle(pub(crate) super::tree::CstNodeId);
5293impl NonTerminalHandle for LParenHandle {
5294 type View = LParenView;
5295 fn node_id(&self) -> CstNodeId {
5296 self.0
5297 }
5298 fn new_with_visit<F: CstFacade, E>(
5299 index: CstNodeId,
5300 tree: &F,
5301 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5302 ) -> Result<Self, CstConstructError<E>> {
5303 tree.collect_nodes(
5304 index,
5305 [NodeKind::NonTerminal(NonTerminalKind::LParen)],
5306 |[index], visit| Ok((Self(index), visit)),
5307 visit_ignored,
5308 )
5309 }
5310 fn kind(&self) -> NonTerminalKind {
5311 NonTerminalKind::LParen
5312 }
5313 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5314 &self,
5315 tree: &F,
5316 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5317 visit_ignored: &'v mut V,
5318 ) -> Result<O, CstConstructError<E>> {
5319 tree.collect_nodes(
5320 self.0,
5321 [NodeKind::Terminal(TerminalKind::LParen)],
5322 |[l_paren], visit_ignored| {
5323 Ok(visit(
5324 LParenView {
5325 l_paren: LParen(l_paren),
5326 },
5327 visit_ignored,
5328 ))
5329 },
5330 visit_ignored,
5331 )
5332 }
5333}
5334#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5335pub struct LParenView {
5336 pub l_paren: LParen,
5337}
5338impl LParenView {}
5339#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5340pub struct LitStrHandle(pub(crate) super::tree::CstNodeId);
5341impl NonTerminalHandle for LitStrHandle {
5342 type View = LitStrView;
5343 fn node_id(&self) -> CstNodeId {
5344 self.0
5345 }
5346 fn new_with_visit<F: CstFacade, E>(
5347 index: CstNodeId,
5348 tree: &F,
5349 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5350 ) -> Result<Self, CstConstructError<E>> {
5351 tree.collect_nodes(
5352 index,
5353 [NodeKind::NonTerminal(NonTerminalKind::LitStr)],
5354 |[index], visit| Ok((Self(index), visit)),
5355 visit_ignored,
5356 )
5357 }
5358 fn kind(&self) -> NonTerminalKind {
5359 NonTerminalKind::LitStr
5360 }
5361 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5362 &self,
5363 tree: &F,
5364 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5365 visit_ignored: &'v mut V,
5366 ) -> Result<O, CstConstructError<E>> {
5367 tree.collect_nodes(
5368 self.0,
5369 [NodeKind::Terminal(TerminalKind::LitStr)],
5370 |[lit_str], visit_ignored| {
5371 Ok(visit(
5372 LitStrView {
5373 lit_str: LitStr(lit_str),
5374 },
5375 visit_ignored,
5376 ))
5377 },
5378 visit_ignored,
5379 )
5380 }
5381}
5382#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5383pub struct LitStrView {
5384 pub lit_str: LitStr,
5385}
5386impl LitStrView {}
5387#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5388pub struct LitStr1Handle(pub(crate) super::tree::CstNodeId);
5389impl NonTerminalHandle for LitStr1Handle {
5390 type View = LitStr1View;
5391 fn node_id(&self) -> CstNodeId {
5392 self.0
5393 }
5394 fn new_with_visit<F: CstFacade, E>(
5395 index: CstNodeId,
5396 tree: &F,
5397 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5398 ) -> Result<Self, CstConstructError<E>> {
5399 tree.collect_nodes(
5400 index,
5401 [NodeKind::NonTerminal(NonTerminalKind::LitStr1)],
5402 |[index], visit| Ok((Self(index), visit)),
5403 visit_ignored,
5404 )
5405 }
5406 fn kind(&self) -> NonTerminalKind {
5407 NonTerminalKind::LitStr1
5408 }
5409 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5410 &self,
5411 tree: &F,
5412 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5413 visit_ignored: &'v mut V,
5414 ) -> Result<O, CstConstructError<E>> {
5415 tree.collect_nodes(
5416 self.0,
5417 [
5418 NodeKind::NonTerminal(NonTerminalKind::LitStr1Start),
5419 NodeKind::NonTerminal(NonTerminalKind::LitStr1List),
5420 NodeKind::NonTerminal(NonTerminalKind::LitStr1End),
5421 ],
5422 |[lit_str_1_start, lit_str_1_list, lit_str_1_end], visit_ignored| {
5423 Ok(visit(
5424 LitStr1View {
5425 lit_str_1_start: LitStr1StartHandle(lit_str_1_start),
5426 lit_str_1_list: LitStr1ListHandle(lit_str_1_list),
5427 lit_str_1_end: LitStr1EndHandle(lit_str_1_end),
5428 },
5429 visit_ignored,
5430 ))
5431 },
5432 visit_ignored,
5433 )
5434 }
5435}
5436#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5437pub struct LitStr1View {
5438 pub lit_str_1_start: LitStr1StartHandle,
5439 pub lit_str_1_list: LitStr1ListHandle,
5440 pub lit_str_1_end: LitStr1EndHandle,
5441}
5442impl LitStr1View {}
5443#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5444pub struct LitStr1EndHandle(pub(crate) super::tree::CstNodeId);
5445impl NonTerminalHandle for LitStr1EndHandle {
5446 type View = LitStr1EndView;
5447 fn node_id(&self) -> CstNodeId {
5448 self.0
5449 }
5450 fn new_with_visit<F: CstFacade, E>(
5451 index: CstNodeId,
5452 tree: &F,
5453 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5454 ) -> Result<Self, CstConstructError<E>> {
5455 tree.collect_nodes(
5456 index,
5457 [NodeKind::NonTerminal(NonTerminalKind::LitStr1End)],
5458 |[index], visit| Ok((Self(index), visit)),
5459 visit_ignored,
5460 )
5461 }
5462 fn kind(&self) -> NonTerminalKind {
5463 NonTerminalKind::LitStr1End
5464 }
5465 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5466 &self,
5467 tree: &F,
5468 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5469 visit_ignored: &'v mut V,
5470 ) -> Result<O, CstConstructError<E>> {
5471 tree.collect_nodes(
5472 self.0,
5473 [NodeKind::Terminal(TerminalKind::LitStr1End)],
5474 |[lit_str_1_end], visit_ignored| {
5475 Ok(visit(
5476 LitStr1EndView {
5477 lit_str_1_end: LitStr1End(lit_str_1_end),
5478 },
5479 visit_ignored,
5480 ))
5481 },
5482 visit_ignored,
5483 )
5484 }
5485}
5486#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5487pub struct LitStr1EndView {
5488 pub lit_str_1_end: LitStr1End,
5489}
5490impl LitStr1EndView {}
5491#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5492pub struct LitStr1ListHandle(pub(crate) super::tree::CstNodeId);
5493impl NonTerminalHandle for LitStr1ListHandle {
5494 type View = Option<LitStr1ListView>;
5495 fn node_id(&self) -> CstNodeId {
5496 self.0
5497 }
5498 fn new_with_visit<F: CstFacade, E>(
5499 index: CstNodeId,
5500 tree: &F,
5501 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5502 ) -> Result<Self, CstConstructError<E>> {
5503 tree.collect_nodes(
5504 index,
5505 [NodeKind::NonTerminal(NonTerminalKind::LitStr1List)],
5506 |[index], visit| Ok((Self(index), visit)),
5507 visit_ignored,
5508 )
5509 }
5510 fn kind(&self) -> NonTerminalKind {
5511 NonTerminalKind::LitStr1List
5512 }
5513 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5514 &self,
5515 tree: &F,
5516 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5517 visit_ignored: &'v mut V,
5518 ) -> Result<O, CstConstructError<E>> {
5519 if tree.has_no_children(self.0) {
5520 return Ok(visit(None, visit_ignored).0);
5521 }
5522 tree.collect_nodes(
5523 self.0,
5524 [
5525 NodeKind::NonTerminal(NonTerminalKind::LitStr1ListGroup),
5526 NodeKind::NonTerminal(NonTerminalKind::LitStr1List),
5527 ],
5528 |[lit_str_1_list_group, lit_str_1_list], visit_ignored| {
5529 Ok(visit(
5530 Some(LitStr1ListView {
5531 lit_str_1_list_group: LitStr1ListGroupHandle(lit_str_1_list_group),
5532 lit_str_1_list: LitStr1ListHandle(lit_str_1_list),
5533 }),
5534 visit_ignored,
5535 ))
5536 },
5537 visit_ignored,
5538 )
5539 }
5540}
5541#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5542pub struct LitStr1ListView {
5543 pub lit_str_1_list_group: LitStr1ListGroupHandle,
5544 pub lit_str_1_list: LitStr1ListHandle,
5545}
5546impl<F: CstFacade> RecursiveView<F> for LitStr1ListView {
5547 type Item = LitStr1ListGroupHandle;
5548 fn get_all_with_visit<E>(
5549 &self,
5550 tree: &F,
5551 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5552 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5553 let mut items = Vec::new();
5554 let mut current_view = Some(*self);
5555 while let Some(item) = current_view {
5556 let Self {
5557 lit_str_1_list_group,
5558 ..
5559 } = item;
5560 items.push(lit_str_1_list_group);
5561 item.lit_str_1_list.get_view_with_visit(
5562 tree,
5563 |view, visit_ignored| {
5564 current_view = view;
5565 ((), visit_ignored)
5566 },
5567 visit_ignored,
5568 )?;
5569 }
5570 Ok(items)
5571 }
5572}
5573#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5574pub struct LitStr1ListGroupHandle(pub(crate) super::tree::CstNodeId);
5575impl NonTerminalHandle for LitStr1ListGroupHandle {
5576 type View = LitStr1ListGroupView;
5577 fn node_id(&self) -> CstNodeId {
5578 self.0
5579 }
5580 fn new_with_visit<F: CstFacade, E>(
5581 index: CstNodeId,
5582 tree: &F,
5583 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5584 ) -> Result<Self, CstConstructError<E>> {
5585 tree.collect_nodes(
5586 index,
5587 [NodeKind::NonTerminal(NonTerminalKind::LitStr1ListGroup)],
5588 |[index], visit| Ok((Self(index), visit)),
5589 visit_ignored,
5590 )
5591 }
5592 fn kind(&self) -> NonTerminalKind {
5593 NonTerminalKind::LitStr1ListGroup
5594 }
5595 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5596 &self,
5597 tree: &F,
5598 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5599 visit_ignored: &'v mut V,
5600 ) -> Result<O, CstConstructError<E>> {
5601 let mut children = tree.children(self.0);
5602 let Some(child) = children.next() else {
5603 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5604 };
5605 let Some(child_data) = tree.node_data(child) else {
5606 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5607 };
5608 let variant = match child_data.node_kind() {
5609 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5610 LitStr1ListGroupView::NoSQuote(NoSQuoteHandle(child))
5611 }
5612 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5613 LitStr1ListGroupView::SQuote(SQuoteHandle(child))
5614 }
5615 _ => {
5616 return Err(ViewConstructionError::UnexpectedNode {
5617 node: child,
5618 data: child_data,
5619 expected_kind: child_data.node_kind(),
5620 });
5621 }
5622 };
5623 let (result, _visit) = visit(variant, visit_ignored);
5624 if let Some(extra_child) = children.next() {
5625 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5626 }
5627 Ok(result)
5628 }
5629}
5630#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5631pub enum LitStr1ListGroupView {
5632 NoSQuote(NoSQuoteHandle),
5633 SQuote(SQuoteHandle),
5634}
5635impl LitStr1ListGroupView {}
5636#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5637pub struct LitStr1StartHandle(pub(crate) super::tree::CstNodeId);
5638impl NonTerminalHandle for LitStr1StartHandle {
5639 type View = LitStr1StartView;
5640 fn node_id(&self) -> CstNodeId {
5641 self.0
5642 }
5643 fn new_with_visit<F: CstFacade, E>(
5644 index: CstNodeId,
5645 tree: &F,
5646 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5647 ) -> Result<Self, CstConstructError<E>> {
5648 tree.collect_nodes(
5649 index,
5650 [NodeKind::NonTerminal(NonTerminalKind::LitStr1Start)],
5651 |[index], visit| Ok((Self(index), visit)),
5652 visit_ignored,
5653 )
5654 }
5655 fn kind(&self) -> NonTerminalKind {
5656 NonTerminalKind::LitStr1Start
5657 }
5658 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5659 &self,
5660 tree: &F,
5661 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5662 visit_ignored: &'v mut V,
5663 ) -> Result<O, CstConstructError<E>> {
5664 tree.collect_nodes(
5665 self.0,
5666 [NodeKind::Terminal(TerminalKind::LitStr1Start)],
5667 |[lit_str_1_start], visit_ignored| {
5668 Ok(visit(
5669 LitStr1StartView {
5670 lit_str_1_start: LitStr1Start(lit_str_1_start),
5671 },
5672 visit_ignored,
5673 ))
5674 },
5675 visit_ignored,
5676 )
5677 }
5678}
5679#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5680pub struct LitStr1StartView {
5681 pub lit_str_1_start: LitStr1Start,
5682}
5683impl LitStr1StartView {}
5684#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5685pub struct LitStr2Handle(pub(crate) super::tree::CstNodeId);
5686impl NonTerminalHandle for LitStr2Handle {
5687 type View = LitStr2View;
5688 fn node_id(&self) -> CstNodeId {
5689 self.0
5690 }
5691 fn new_with_visit<F: CstFacade, E>(
5692 index: CstNodeId,
5693 tree: &F,
5694 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5695 ) -> Result<Self, CstConstructError<E>> {
5696 tree.collect_nodes(
5697 index,
5698 [NodeKind::NonTerminal(NonTerminalKind::LitStr2)],
5699 |[index], visit| Ok((Self(index), visit)),
5700 visit_ignored,
5701 )
5702 }
5703 fn kind(&self) -> NonTerminalKind {
5704 NonTerminalKind::LitStr2
5705 }
5706 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5707 &self,
5708 tree: &F,
5709 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5710 visit_ignored: &'v mut V,
5711 ) -> Result<O, CstConstructError<E>> {
5712 tree.collect_nodes(
5713 self.0,
5714 [
5715 NodeKind::NonTerminal(NonTerminalKind::LitStr2Start),
5716 NodeKind::NonTerminal(NonTerminalKind::LitStr2List),
5717 NodeKind::NonTerminal(NonTerminalKind::LitStr2End),
5718 ],
5719 |[lit_str_2_start, lit_str_2_list, lit_str_2_end], visit_ignored| {
5720 Ok(visit(
5721 LitStr2View {
5722 lit_str_2_start: LitStr2StartHandle(lit_str_2_start),
5723 lit_str_2_list: LitStr2ListHandle(lit_str_2_list),
5724 lit_str_2_end: LitStr2EndHandle(lit_str_2_end),
5725 },
5726 visit_ignored,
5727 ))
5728 },
5729 visit_ignored,
5730 )
5731 }
5732}
5733#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5734pub struct LitStr2View {
5735 pub lit_str_2_start: LitStr2StartHandle,
5736 pub lit_str_2_list: LitStr2ListHandle,
5737 pub lit_str_2_end: LitStr2EndHandle,
5738}
5739impl LitStr2View {}
5740#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5741pub struct LitStr2EndHandle(pub(crate) super::tree::CstNodeId);
5742impl NonTerminalHandle for LitStr2EndHandle {
5743 type View = LitStr2EndView;
5744 fn node_id(&self) -> CstNodeId {
5745 self.0
5746 }
5747 fn new_with_visit<F: CstFacade, E>(
5748 index: CstNodeId,
5749 tree: &F,
5750 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5751 ) -> Result<Self, CstConstructError<E>> {
5752 tree.collect_nodes(
5753 index,
5754 [NodeKind::NonTerminal(NonTerminalKind::LitStr2End)],
5755 |[index], visit| Ok((Self(index), visit)),
5756 visit_ignored,
5757 )
5758 }
5759 fn kind(&self) -> NonTerminalKind {
5760 NonTerminalKind::LitStr2End
5761 }
5762 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5763 &self,
5764 tree: &F,
5765 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5766 visit_ignored: &'v mut V,
5767 ) -> Result<O, CstConstructError<E>> {
5768 tree.collect_nodes(
5769 self.0,
5770 [NodeKind::Terminal(TerminalKind::LitStr2End)],
5771 |[lit_str_2_end], visit_ignored| {
5772 Ok(visit(
5773 LitStr2EndView {
5774 lit_str_2_end: LitStr2End(lit_str_2_end),
5775 },
5776 visit_ignored,
5777 ))
5778 },
5779 visit_ignored,
5780 )
5781 }
5782}
5783#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5784pub struct LitStr2EndView {
5785 pub lit_str_2_end: LitStr2End,
5786}
5787impl LitStr2EndView {}
5788#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5789pub struct LitStr2ListHandle(pub(crate) super::tree::CstNodeId);
5790impl NonTerminalHandle for LitStr2ListHandle {
5791 type View = Option<LitStr2ListView>;
5792 fn node_id(&self) -> CstNodeId {
5793 self.0
5794 }
5795 fn new_with_visit<F: CstFacade, E>(
5796 index: CstNodeId,
5797 tree: &F,
5798 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5799 ) -> Result<Self, CstConstructError<E>> {
5800 tree.collect_nodes(
5801 index,
5802 [NodeKind::NonTerminal(NonTerminalKind::LitStr2List)],
5803 |[index], visit| Ok((Self(index), visit)),
5804 visit_ignored,
5805 )
5806 }
5807 fn kind(&self) -> NonTerminalKind {
5808 NonTerminalKind::LitStr2List
5809 }
5810 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5811 &self,
5812 tree: &F,
5813 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5814 visit_ignored: &'v mut V,
5815 ) -> Result<O, CstConstructError<E>> {
5816 if tree.has_no_children(self.0) {
5817 return Ok(visit(None, visit_ignored).0);
5818 }
5819 tree.collect_nodes(
5820 self.0,
5821 [
5822 NodeKind::NonTerminal(NonTerminalKind::LitStr2ListGroup),
5823 NodeKind::NonTerminal(NonTerminalKind::LitStr2List),
5824 ],
5825 |[lit_str_2_list_group, lit_str_2_list], visit_ignored| {
5826 Ok(visit(
5827 Some(LitStr2ListView {
5828 lit_str_2_list_group: LitStr2ListGroupHandle(lit_str_2_list_group),
5829 lit_str_2_list: LitStr2ListHandle(lit_str_2_list),
5830 }),
5831 visit_ignored,
5832 ))
5833 },
5834 visit_ignored,
5835 )
5836 }
5837}
5838#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5839pub struct LitStr2ListView {
5840 pub lit_str_2_list_group: LitStr2ListGroupHandle,
5841 pub lit_str_2_list: LitStr2ListHandle,
5842}
5843impl<F: CstFacade> RecursiveView<F> for LitStr2ListView {
5844 type Item = LitStr2ListGroupHandle;
5845 fn get_all_with_visit<E>(
5846 &self,
5847 tree: &F,
5848 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5849 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5850 let mut items = Vec::new();
5851 let mut current_view = Some(*self);
5852 while let Some(item) = current_view {
5853 let Self {
5854 lit_str_2_list_group,
5855 ..
5856 } = item;
5857 items.push(lit_str_2_list_group);
5858 item.lit_str_2_list.get_view_with_visit(
5859 tree,
5860 |view, visit_ignored| {
5861 current_view = view;
5862 ((), visit_ignored)
5863 },
5864 visit_ignored,
5865 )?;
5866 }
5867 Ok(items)
5868 }
5869}
5870#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5871pub struct LitStr2ListGroupHandle(pub(crate) super::tree::CstNodeId);
5872impl NonTerminalHandle for LitStr2ListGroupHandle {
5873 type View = LitStr2ListGroupView;
5874 fn node_id(&self) -> CstNodeId {
5875 self.0
5876 }
5877 fn new_with_visit<F: CstFacade, E>(
5878 index: CstNodeId,
5879 tree: &F,
5880 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5881 ) -> Result<Self, CstConstructError<E>> {
5882 tree.collect_nodes(
5883 index,
5884 [NodeKind::NonTerminal(NonTerminalKind::LitStr2ListGroup)],
5885 |[index], visit| Ok((Self(index), visit)),
5886 visit_ignored,
5887 )
5888 }
5889 fn kind(&self) -> NonTerminalKind {
5890 NonTerminalKind::LitStr2ListGroup
5891 }
5892 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5893 &self,
5894 tree: &F,
5895 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5896 visit_ignored: &'v mut V,
5897 ) -> Result<O, CstConstructError<E>> {
5898 let mut children = tree.children(self.0);
5899 let Some(child) = children.next() else {
5900 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5901 };
5902 let Some(child_data) = tree.node_data(child) else {
5903 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5904 };
5905 let variant = match child_data.node_kind() {
5906 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5907 LitStr2ListGroupView::NoSQuote(NoSQuoteHandle(child))
5908 }
5909 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5910 LitStr2ListGroupView::SQuote(SQuoteHandle(child))
5911 }
5912 _ => {
5913 return Err(ViewConstructionError::UnexpectedNode {
5914 node: child,
5915 data: child_data,
5916 expected_kind: child_data.node_kind(),
5917 });
5918 }
5919 };
5920 let (result, _visit) = visit(variant, visit_ignored);
5921 if let Some(extra_child) = children.next() {
5922 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5923 }
5924 Ok(result)
5925 }
5926}
5927#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5928pub enum LitStr2ListGroupView {
5929 NoSQuote(NoSQuoteHandle),
5930 SQuote(SQuoteHandle),
5931}
5932impl LitStr2ListGroupView {}
5933#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5934pub struct LitStr2StartHandle(pub(crate) super::tree::CstNodeId);
5935impl NonTerminalHandle for LitStr2StartHandle {
5936 type View = LitStr2StartView;
5937 fn node_id(&self) -> CstNodeId {
5938 self.0
5939 }
5940 fn new_with_visit<F: CstFacade, E>(
5941 index: CstNodeId,
5942 tree: &F,
5943 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5944 ) -> Result<Self, CstConstructError<E>> {
5945 tree.collect_nodes(
5946 index,
5947 [NodeKind::NonTerminal(NonTerminalKind::LitStr2Start)],
5948 |[index], visit| Ok((Self(index), visit)),
5949 visit_ignored,
5950 )
5951 }
5952 fn kind(&self) -> NonTerminalKind {
5953 NonTerminalKind::LitStr2Start
5954 }
5955 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5956 &self,
5957 tree: &F,
5958 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5959 visit_ignored: &'v mut V,
5960 ) -> Result<O, CstConstructError<E>> {
5961 tree.collect_nodes(
5962 self.0,
5963 [NodeKind::Terminal(TerminalKind::LitStr2Start)],
5964 |[lit_str_2_start], visit_ignored| {
5965 Ok(visit(
5966 LitStr2StartView {
5967 lit_str_2_start: LitStr2Start(lit_str_2_start),
5968 },
5969 visit_ignored,
5970 ))
5971 },
5972 visit_ignored,
5973 )
5974 }
5975}
5976#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5977pub struct LitStr2StartView {
5978 pub lit_str_2_start: LitStr2Start,
5979}
5980impl LitStr2StartView {}
5981#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5982pub struct LitStr3Handle(pub(crate) super::tree::CstNodeId);
5983impl NonTerminalHandle for LitStr3Handle {
5984 type View = LitStr3View;
5985 fn node_id(&self) -> CstNodeId {
5986 self.0
5987 }
5988 fn new_with_visit<F: CstFacade, E>(
5989 index: CstNodeId,
5990 tree: &F,
5991 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5992 ) -> Result<Self, CstConstructError<E>> {
5993 tree.collect_nodes(
5994 index,
5995 [NodeKind::NonTerminal(NonTerminalKind::LitStr3)],
5996 |[index], visit| Ok((Self(index), visit)),
5997 visit_ignored,
5998 )
5999 }
6000 fn kind(&self) -> NonTerminalKind {
6001 NonTerminalKind::LitStr3
6002 }
6003 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6004 &self,
6005 tree: &F,
6006 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6007 visit_ignored: &'v mut V,
6008 ) -> Result<O, CstConstructError<E>> {
6009 tree.collect_nodes(
6010 self.0,
6011 [
6012 NodeKind::NonTerminal(NonTerminalKind::LitStr3Start),
6013 NodeKind::NonTerminal(NonTerminalKind::LitStr3List),
6014 NodeKind::NonTerminal(NonTerminalKind::LitStr3End),
6015 ],
6016 |[lit_str_3_start, lit_str_3_list, lit_str_3_end], visit_ignored| {
6017 Ok(visit(
6018 LitStr3View {
6019 lit_str_3_start: LitStr3StartHandle(lit_str_3_start),
6020 lit_str_3_list: LitStr3ListHandle(lit_str_3_list),
6021 lit_str_3_end: LitStr3EndHandle(lit_str_3_end),
6022 },
6023 visit_ignored,
6024 ))
6025 },
6026 visit_ignored,
6027 )
6028 }
6029}
6030#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6031pub struct LitStr3View {
6032 pub lit_str_3_start: LitStr3StartHandle,
6033 pub lit_str_3_list: LitStr3ListHandle,
6034 pub lit_str_3_end: LitStr3EndHandle,
6035}
6036impl LitStr3View {}
6037#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6038pub struct LitStr3EndHandle(pub(crate) super::tree::CstNodeId);
6039impl NonTerminalHandle for LitStr3EndHandle {
6040 type View = LitStr3EndView;
6041 fn node_id(&self) -> CstNodeId {
6042 self.0
6043 }
6044 fn new_with_visit<F: CstFacade, E>(
6045 index: CstNodeId,
6046 tree: &F,
6047 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6048 ) -> Result<Self, CstConstructError<E>> {
6049 tree.collect_nodes(
6050 index,
6051 [NodeKind::NonTerminal(NonTerminalKind::LitStr3End)],
6052 |[index], visit| Ok((Self(index), visit)),
6053 visit_ignored,
6054 )
6055 }
6056 fn kind(&self) -> NonTerminalKind {
6057 NonTerminalKind::LitStr3End
6058 }
6059 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6060 &self,
6061 tree: &F,
6062 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6063 visit_ignored: &'v mut V,
6064 ) -> Result<O, CstConstructError<E>> {
6065 tree.collect_nodes(
6066 self.0,
6067 [NodeKind::Terminal(TerminalKind::LitStr3End)],
6068 |[lit_str_3_end], visit_ignored| {
6069 Ok(visit(
6070 LitStr3EndView {
6071 lit_str_3_end: LitStr3End(lit_str_3_end),
6072 },
6073 visit_ignored,
6074 ))
6075 },
6076 visit_ignored,
6077 )
6078 }
6079}
6080#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6081pub struct LitStr3EndView {
6082 pub lit_str_3_end: LitStr3End,
6083}
6084impl LitStr3EndView {}
6085#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6086pub struct LitStr3ListHandle(pub(crate) super::tree::CstNodeId);
6087impl NonTerminalHandle for LitStr3ListHandle {
6088 type View = Option<LitStr3ListView>;
6089 fn node_id(&self) -> CstNodeId {
6090 self.0
6091 }
6092 fn new_with_visit<F: CstFacade, E>(
6093 index: CstNodeId,
6094 tree: &F,
6095 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6096 ) -> Result<Self, CstConstructError<E>> {
6097 tree.collect_nodes(
6098 index,
6099 [NodeKind::NonTerminal(NonTerminalKind::LitStr3List)],
6100 |[index], visit| Ok((Self(index), visit)),
6101 visit_ignored,
6102 )
6103 }
6104 fn kind(&self) -> NonTerminalKind {
6105 NonTerminalKind::LitStr3List
6106 }
6107 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6108 &self,
6109 tree: &F,
6110 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6111 visit_ignored: &'v mut V,
6112 ) -> Result<O, CstConstructError<E>> {
6113 if tree.has_no_children(self.0) {
6114 return Ok(visit(None, visit_ignored).0);
6115 }
6116 tree.collect_nodes(
6117 self.0,
6118 [
6119 NodeKind::NonTerminal(NonTerminalKind::LitStr3ListGroup),
6120 NodeKind::NonTerminal(NonTerminalKind::LitStr3List),
6121 ],
6122 |[lit_str_3_list_group, lit_str_3_list], visit_ignored| {
6123 Ok(visit(
6124 Some(LitStr3ListView {
6125 lit_str_3_list_group: LitStr3ListGroupHandle(lit_str_3_list_group),
6126 lit_str_3_list: LitStr3ListHandle(lit_str_3_list),
6127 }),
6128 visit_ignored,
6129 ))
6130 },
6131 visit_ignored,
6132 )
6133 }
6134}
6135#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6136pub struct LitStr3ListView {
6137 pub lit_str_3_list_group: LitStr3ListGroupHandle,
6138 pub lit_str_3_list: LitStr3ListHandle,
6139}
6140impl<F: CstFacade> RecursiveView<F> for LitStr3ListView {
6141 type Item = LitStr3ListGroupHandle;
6142 fn get_all_with_visit<E>(
6143 &self,
6144 tree: &F,
6145 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6146 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
6147 let mut items = Vec::new();
6148 let mut current_view = Some(*self);
6149 while let Some(item) = current_view {
6150 let Self {
6151 lit_str_3_list_group,
6152 ..
6153 } = item;
6154 items.push(lit_str_3_list_group);
6155 item.lit_str_3_list.get_view_with_visit(
6156 tree,
6157 |view, visit_ignored| {
6158 current_view = view;
6159 ((), visit_ignored)
6160 },
6161 visit_ignored,
6162 )?;
6163 }
6164 Ok(items)
6165 }
6166}
6167#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6168pub struct LitStr3ListGroupHandle(pub(crate) super::tree::CstNodeId);
6169impl NonTerminalHandle for LitStr3ListGroupHandle {
6170 type View = LitStr3ListGroupView;
6171 fn node_id(&self) -> CstNodeId {
6172 self.0
6173 }
6174 fn new_with_visit<F: CstFacade, E>(
6175 index: CstNodeId,
6176 tree: &F,
6177 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6178 ) -> Result<Self, CstConstructError<E>> {
6179 tree.collect_nodes(
6180 index,
6181 [NodeKind::NonTerminal(NonTerminalKind::LitStr3ListGroup)],
6182 |[index], visit| Ok((Self(index), visit)),
6183 visit_ignored,
6184 )
6185 }
6186 fn kind(&self) -> NonTerminalKind {
6187 NonTerminalKind::LitStr3ListGroup
6188 }
6189 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6190 &self,
6191 tree: &F,
6192 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6193 visit_ignored: &'v mut V,
6194 ) -> Result<O, CstConstructError<E>> {
6195 let mut children = tree.children(self.0);
6196 let Some(child) = children.next() else {
6197 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6198 };
6199 let Some(child_data) = tree.node_data(child) else {
6200 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6201 };
6202 let variant = match child_data.node_kind() {
6203 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
6204 LitStr3ListGroupView::NoSQuote(NoSQuoteHandle(child))
6205 }
6206 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
6207 LitStr3ListGroupView::SQuote(SQuoteHandle(child))
6208 }
6209 _ => {
6210 return Err(ViewConstructionError::UnexpectedNode {
6211 node: child,
6212 data: child_data,
6213 expected_kind: child_data.node_kind(),
6214 });
6215 }
6216 };
6217 let (result, _visit) = visit(variant, visit_ignored);
6218 if let Some(extra_child) = children.next() {
6219 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6220 }
6221 Ok(result)
6222 }
6223}
6224#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6225pub enum LitStr3ListGroupView {
6226 NoSQuote(NoSQuoteHandle),
6227 SQuote(SQuoteHandle),
6228}
6229impl LitStr3ListGroupView {}
6230#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6231pub struct LitStr3StartHandle(pub(crate) super::tree::CstNodeId);
6232impl NonTerminalHandle for LitStr3StartHandle {
6233 type View = LitStr3StartView;
6234 fn node_id(&self) -> CstNodeId {
6235 self.0
6236 }
6237 fn new_with_visit<F: CstFacade, E>(
6238 index: CstNodeId,
6239 tree: &F,
6240 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6241 ) -> Result<Self, CstConstructError<E>> {
6242 tree.collect_nodes(
6243 index,
6244 [NodeKind::NonTerminal(NonTerminalKind::LitStr3Start)],
6245 |[index], visit| Ok((Self(index), visit)),
6246 visit_ignored,
6247 )
6248 }
6249 fn kind(&self) -> NonTerminalKind {
6250 NonTerminalKind::LitStr3Start
6251 }
6252 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6253 &self,
6254 tree: &F,
6255 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6256 visit_ignored: &'v mut V,
6257 ) -> Result<O, CstConstructError<E>> {
6258 tree.collect_nodes(
6259 self.0,
6260 [NodeKind::Terminal(TerminalKind::LitStr3Start)],
6261 |[lit_str_3_start], visit_ignored| {
6262 Ok(visit(
6263 LitStr3StartView {
6264 lit_str_3_start: LitStr3Start(lit_str_3_start),
6265 },
6266 visit_ignored,
6267 ))
6268 },
6269 visit_ignored,
6270 )
6271 }
6272}
6273#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6274pub struct LitStr3StartView {
6275 pub lit_str_3_start: LitStr3Start,
6276}
6277impl LitStr3StartView {}
6278#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6279pub struct MapBindHandle(pub(crate) super::tree::CstNodeId);
6280impl NonTerminalHandle for MapBindHandle {
6281 type View = MapBindView;
6282 fn node_id(&self) -> CstNodeId {
6283 self.0
6284 }
6285 fn new_with_visit<F: CstFacade, E>(
6286 index: CstNodeId,
6287 tree: &F,
6288 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6289 ) -> Result<Self, CstConstructError<E>> {
6290 tree.collect_nodes(
6291 index,
6292 [NodeKind::NonTerminal(NonTerminalKind::MapBind)],
6293 |[index], visit| Ok((Self(index), visit)),
6294 visit_ignored,
6295 )
6296 }
6297 fn kind(&self) -> NonTerminalKind {
6298 NonTerminalKind::MapBind
6299 }
6300 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6301 &self,
6302 tree: &F,
6303 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6304 visit_ignored: &'v mut V,
6305 ) -> Result<O, CstConstructError<E>> {
6306 tree.collect_nodes(
6307 self.0,
6308 [NodeKind::Terminal(TerminalKind::MapBind)],
6309 |[map_bind], visit_ignored| {
6310 Ok(visit(
6311 MapBindView {
6312 map_bind: MapBind(map_bind),
6313 },
6314 visit_ignored,
6315 ))
6316 },
6317 visit_ignored,
6318 )
6319 }
6320}
6321#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6322pub struct MapBindView {
6323 pub map_bind: MapBind,
6324}
6325impl MapBindView {}
6326#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6327pub struct NaNHandle(pub(crate) super::tree::CstNodeId);
6328impl NonTerminalHandle for NaNHandle {
6329 type View = NaNView;
6330 fn node_id(&self) -> CstNodeId {
6331 self.0
6332 }
6333 fn new_with_visit<F: CstFacade, E>(
6334 index: CstNodeId,
6335 tree: &F,
6336 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6337 ) -> Result<Self, CstConstructError<E>> {
6338 tree.collect_nodes(
6339 index,
6340 [NodeKind::NonTerminal(NonTerminalKind::NaN)],
6341 |[index], visit| Ok((Self(index), visit)),
6342 visit_ignored,
6343 )
6344 }
6345 fn kind(&self) -> NonTerminalKind {
6346 NonTerminalKind::NaN
6347 }
6348 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6349 &self,
6350 tree: &F,
6351 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6352 visit_ignored: &'v mut V,
6353 ) -> Result<O, CstConstructError<E>> {
6354 tree.collect_nodes(
6355 self.0,
6356 [NodeKind::Terminal(TerminalKind::NaN)],
6357 |[na_n], visit_ignored| Ok(visit(NaNView { na_n: NaN(na_n) }, visit_ignored)),
6358 visit_ignored,
6359 )
6360 }
6361}
6362#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6363pub struct NaNView {
6364 pub na_n: NaN,
6365}
6366impl NaNView {}
6367#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6368pub struct NewlineBindHandle(pub(crate) super::tree::CstNodeId);
6369impl NonTerminalHandle for NewlineBindHandle {
6370 type View = NewlineBindView;
6371 fn node_id(&self) -> CstNodeId {
6372 self.0
6373 }
6374 fn new_with_visit<F: CstFacade, E>(
6375 index: CstNodeId,
6376 tree: &F,
6377 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6378 ) -> Result<Self, CstConstructError<E>> {
6379 tree.collect_nodes(
6380 index,
6381 [NodeKind::NonTerminal(NonTerminalKind::NewlineBind)],
6382 |[index], visit| Ok((Self(index), visit)),
6383 visit_ignored,
6384 )
6385 }
6386 fn kind(&self) -> NonTerminalKind {
6387 NonTerminalKind::NewlineBind
6388 }
6389 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6390 &self,
6391 tree: &F,
6392 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6393 visit_ignored: &'v mut V,
6394 ) -> Result<O, CstConstructError<E>> {
6395 tree.collect_nodes(
6396 self.0,
6397 [NodeKind::Terminal(TerminalKind::NewlineBind)],
6398 |[newline_bind], visit_ignored| {
6399 Ok(visit(
6400 NewlineBindView {
6401 newline_bind: NewlineBind(newline_bind),
6402 },
6403 visit_ignored,
6404 ))
6405 },
6406 visit_ignored,
6407 )
6408 }
6409}
6410#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6411pub struct NewlineBindView {
6412 pub newline_bind: NewlineBind,
6413}
6414impl NewlineBindView {}
6415#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6416pub struct NewlineHeadHandle(pub(crate) super::tree::CstNodeId);
6417impl NonTerminalHandle for NewlineHeadHandle {
6418 type View = NewlineHeadView;
6419 fn node_id(&self) -> CstNodeId {
6420 self.0
6421 }
6422 fn new_with_visit<F: CstFacade, E>(
6423 index: CstNodeId,
6424 tree: &F,
6425 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6426 ) -> Result<Self, CstConstructError<E>> {
6427 tree.collect_nodes(
6428 index,
6429 [NodeKind::NonTerminal(NonTerminalKind::NewlineHead)],
6430 |[index], visit| Ok((Self(index), visit)),
6431 visit_ignored,
6432 )
6433 }
6434 fn kind(&self) -> NonTerminalKind {
6435 NonTerminalKind::NewlineHead
6436 }
6437 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6438 &self,
6439 tree: &F,
6440 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6441 visit_ignored: &'v mut V,
6442 ) -> Result<O, CstConstructError<E>> {
6443 tree.collect_nodes(
6444 self.0,
6445 [
6446 NodeKind::NonTerminal(NonTerminalKind::GrammarNewline),
6447 NodeKind::NonTerminal(NonTerminalKind::NewlineHeadOpt),
6448 ],
6449 |[grammar_newline, newline_head_opt], visit_ignored| {
6450 Ok(visit(
6451 NewlineHeadView {
6452 grammar_newline: GrammarNewlineHandle(grammar_newline),
6453 newline_head_opt: NewlineHeadOptHandle(newline_head_opt),
6454 },
6455 visit_ignored,
6456 ))
6457 },
6458 visit_ignored,
6459 )
6460 }
6461}
6462#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6463pub struct NewlineHeadView {
6464 pub grammar_newline: GrammarNewlineHandle,
6465 pub newline_head_opt: NewlineHeadOptHandle,
6466}
6467impl NewlineHeadView {}
6468#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6469pub struct NewlineHeadOptHandle(pub(crate) super::tree::CstNodeId);
6470impl NonTerminalHandle for NewlineHeadOptHandle {
6471 type View = Option<FlatRootBindingHandle>;
6472 fn node_id(&self) -> CstNodeId {
6473 self.0
6474 }
6475 fn new_with_visit<F: CstFacade, E>(
6476 index: CstNodeId,
6477 tree: &F,
6478 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6479 ) -> Result<Self, CstConstructError<E>> {
6480 tree.collect_nodes(
6481 index,
6482 [NodeKind::NonTerminal(NonTerminalKind::NewlineHeadOpt)],
6483 |[index], visit| Ok((Self(index), visit)),
6484 visit_ignored,
6485 )
6486 }
6487 fn kind(&self) -> NonTerminalKind {
6488 NonTerminalKind::NewlineHeadOpt
6489 }
6490 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6491 &self,
6492 tree: &F,
6493 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6494 visit_ignored: &'v mut V,
6495 ) -> Result<O, CstConstructError<E>> {
6496 if tree.has_no_children(self.0) {
6497 return Ok(visit(None, visit_ignored).0);
6498 }
6499 Ok(visit(
6500 Some(FlatRootBindingHandle::new_with_visit(
6501 self.0,
6502 tree,
6503 visit_ignored,
6504 )?),
6505 visit_ignored,
6506 )
6507 .0)
6508 }
6509}
6510#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6511pub struct NewlineTextStartHandle(pub(crate) super::tree::CstNodeId);
6512impl NonTerminalHandle for NewlineTextStartHandle {
6513 type View = NewlineTextStartView;
6514 fn node_id(&self) -> CstNodeId {
6515 self.0
6516 }
6517 fn new_with_visit<F: CstFacade, E>(
6518 index: CstNodeId,
6519 tree: &F,
6520 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6521 ) -> Result<Self, CstConstructError<E>> {
6522 tree.collect_nodes(
6523 index,
6524 [NodeKind::NonTerminal(NonTerminalKind::NewlineTextStart)],
6525 |[index], visit| Ok((Self(index), visit)),
6526 visit_ignored,
6527 )
6528 }
6529 fn kind(&self) -> NonTerminalKind {
6530 NonTerminalKind::NewlineTextStart
6531 }
6532 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6533 &self,
6534 tree: &F,
6535 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6536 visit_ignored: &'v mut V,
6537 ) -> Result<O, CstConstructError<E>> {
6538 tree.collect_nodes(
6539 self.0,
6540 [NodeKind::Terminal(TerminalKind::NewlineTextStart)],
6541 |[newline_text_start], visit_ignored| {
6542 Ok(visit(
6543 NewlineTextStartView {
6544 newline_text_start: NewlineTextStart(newline_text_start),
6545 },
6546 visit_ignored,
6547 ))
6548 },
6549 visit_ignored,
6550 )
6551 }
6552}
6553#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6554pub struct NewlineTextStartView {
6555 pub newline_text_start: NewlineTextStart,
6556}
6557impl NewlineTextStartView {}
6558#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6559pub struct NoBacktickHandle(pub(crate) super::tree::CstNodeId);
6560impl NonTerminalHandle for NoBacktickHandle {
6561 type View = NoBacktickView;
6562 fn node_id(&self) -> CstNodeId {
6563 self.0
6564 }
6565 fn new_with_visit<F: CstFacade, E>(
6566 index: CstNodeId,
6567 tree: &F,
6568 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6569 ) -> Result<Self, CstConstructError<E>> {
6570 tree.collect_nodes(
6571 index,
6572 [NodeKind::NonTerminal(NonTerminalKind::NoBacktick)],
6573 |[index], visit| Ok((Self(index), visit)),
6574 visit_ignored,
6575 )
6576 }
6577 fn kind(&self) -> NonTerminalKind {
6578 NonTerminalKind::NoBacktick
6579 }
6580 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6581 &self,
6582 tree: &F,
6583 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6584 visit_ignored: &'v mut V,
6585 ) -> Result<O, CstConstructError<E>> {
6586 tree.collect_nodes(
6587 self.0,
6588 [NodeKind::Terminal(TerminalKind::NoBacktick)],
6589 |[no_backtick], visit_ignored| {
6590 Ok(visit(
6591 NoBacktickView {
6592 no_backtick: NoBacktick(no_backtick),
6593 },
6594 visit_ignored,
6595 ))
6596 },
6597 visit_ignored,
6598 )
6599 }
6600}
6601#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6602pub struct NoBacktickView {
6603 pub no_backtick: NoBacktick,
6604}
6605impl NoBacktickView {}
6606#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6607pub struct NoSQuoteHandle(pub(crate) super::tree::CstNodeId);
6608impl NonTerminalHandle for NoSQuoteHandle {
6609 type View = NoSQuoteView;
6610 fn node_id(&self) -> CstNodeId {
6611 self.0
6612 }
6613 fn new_with_visit<F: CstFacade, E>(
6614 index: CstNodeId,
6615 tree: &F,
6616 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6617 ) -> Result<Self, CstConstructError<E>> {
6618 tree.collect_nodes(
6619 index,
6620 [NodeKind::NonTerminal(NonTerminalKind::NoSQuote)],
6621 |[index], visit| Ok((Self(index), visit)),
6622 visit_ignored,
6623 )
6624 }
6625 fn kind(&self) -> NonTerminalKind {
6626 NonTerminalKind::NoSQuote
6627 }
6628 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6629 &self,
6630 tree: &F,
6631 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6632 visit_ignored: &'v mut V,
6633 ) -> Result<O, CstConstructError<E>> {
6634 tree.collect_nodes(
6635 self.0,
6636 [NodeKind::Terminal(TerminalKind::NoSQuote)],
6637 |[no_s_quote], visit_ignored| {
6638 Ok(visit(
6639 NoSQuoteView {
6640 no_s_quote: NoSQuote(no_s_quote),
6641 },
6642 visit_ignored,
6643 ))
6644 },
6645 visit_ignored,
6646 )
6647 }
6648}
6649#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6650pub struct NoSQuoteView {
6651 pub no_s_quote: NoSQuote,
6652}
6653impl NoSQuoteView {}
6654#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6655pub struct NullHandle(pub(crate) super::tree::CstNodeId);
6656impl NonTerminalHandle for NullHandle {
6657 type View = NullView;
6658 fn node_id(&self) -> CstNodeId {
6659 self.0
6660 }
6661 fn new_with_visit<F: CstFacade, E>(
6662 index: CstNodeId,
6663 tree: &F,
6664 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6665 ) -> Result<Self, CstConstructError<E>> {
6666 tree.collect_nodes(
6667 index,
6668 [NodeKind::NonTerminal(NonTerminalKind::Null)],
6669 |[index], visit| Ok((Self(index), visit)),
6670 visit_ignored,
6671 )
6672 }
6673 fn kind(&self) -> NonTerminalKind {
6674 NonTerminalKind::Null
6675 }
6676 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6677 &self,
6678 tree: &F,
6679 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6680 visit_ignored: &'v mut V,
6681 ) -> Result<O, CstConstructError<E>> {
6682 tree.collect_nodes(
6683 self.0,
6684 [NodeKind::Terminal(TerminalKind::Null)],
6685 |[null], visit_ignored| Ok(visit(NullView { null: Null(null) }, visit_ignored)),
6686 visit_ignored,
6687 )
6688 }
6689}
6690#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6691pub struct NullView {
6692 pub null: Null,
6693}
6694impl NullView {}
6695#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6696pub struct NumberHandle(pub(crate) super::tree::CstNodeId);
6697impl NonTerminalHandle for NumberHandle {
6698 type View = NumberView;
6699 fn node_id(&self) -> CstNodeId {
6700 self.0
6701 }
6702 fn new_with_visit<F: CstFacade, E>(
6703 index: CstNodeId,
6704 tree: &F,
6705 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6706 ) -> Result<Self, CstConstructError<E>> {
6707 tree.collect_nodes(
6708 index,
6709 [NodeKind::NonTerminal(NonTerminalKind::Number)],
6710 |[index], visit| Ok((Self(index), visit)),
6711 visit_ignored,
6712 )
6713 }
6714 fn kind(&self) -> NonTerminalKind {
6715 NonTerminalKind::Number
6716 }
6717 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6718 &self,
6719 tree: &F,
6720 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6721 visit_ignored: &'v mut V,
6722 ) -> Result<O, CstConstructError<E>> {
6723 let mut children = tree.children(self.0);
6724 let Some(child) = children.next() else {
6725 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6726 };
6727 let Some(child_data) = tree.node_data(child) else {
6728 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6729 };
6730 let variant = match child_data.node_kind() {
6731 NodeKind::NonTerminal(NonTerminalKind::Float) => NumberView::Float(FloatHandle(child)),
6732 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
6733 NumberView::Integer(IntegerHandle(child))
6734 }
6735 NodeKind::NonTerminal(NonTerminalKind::Inf) => NumberView::Inf(InfHandle(child)),
6736 NodeKind::NonTerminal(NonTerminalKind::NaN) => NumberView::NaN(NaNHandle(child)),
6737 _ => {
6738 return Err(ViewConstructionError::UnexpectedNode {
6739 node: child,
6740 data: child_data,
6741 expected_kind: child_data.node_kind(),
6742 });
6743 }
6744 };
6745 let (result, _visit) = visit(variant, visit_ignored);
6746 if let Some(extra_child) = children.next() {
6747 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6748 }
6749 Ok(result)
6750 }
6751}
6752#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6753pub enum NumberView {
6754 Float(FloatHandle),
6755 Integer(IntegerHandle),
6756 Inf(InfHandle),
6757 NaN(NaNHandle),
6758}
6759impl NumberView {}
6760#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6761pub struct ObjectHandle(pub(crate) super::tree::CstNodeId);
6762impl NonTerminalHandle for ObjectHandle {
6763 type View = ObjectView;
6764 fn node_id(&self) -> CstNodeId {
6765 self.0
6766 }
6767 fn new_with_visit<F: CstFacade, E>(
6768 index: CstNodeId,
6769 tree: &F,
6770 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6771 ) -> Result<Self, CstConstructError<E>> {
6772 tree.collect_nodes(
6773 index,
6774 [NodeKind::NonTerminal(NonTerminalKind::Object)],
6775 |[index], visit| Ok((Self(index), visit)),
6776 visit_ignored,
6777 )
6778 }
6779 fn kind(&self) -> NonTerminalKind {
6780 NonTerminalKind::Object
6781 }
6782 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6783 &self,
6784 tree: &F,
6785 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6786 visit_ignored: &'v mut V,
6787 ) -> Result<O, CstConstructError<E>> {
6788 tree.collect_nodes(
6789 self.0,
6790 [
6791 NodeKind::NonTerminal(NonTerminalKind::Begin),
6792 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt),
6793 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
6794 NodeKind::NonTerminal(NonTerminalKind::End),
6795 ],
6796 |[begin, object_opt, object_list, end], visit_ignored| {
6797 Ok(visit(
6798 ObjectView {
6799 begin: BeginHandle(begin),
6800 object_opt: ObjectOptHandle(object_opt),
6801 object_list: ObjectListHandle(object_list),
6802 end: EndHandle(end),
6803 },
6804 visit_ignored,
6805 ))
6806 },
6807 visit_ignored,
6808 )
6809 }
6810}
6811#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6812pub struct ObjectView {
6813 pub begin: BeginHandle,
6814 pub object_opt: ObjectOptHandle,
6815 pub object_list: ObjectListHandle,
6816 pub end: EndHandle,
6817}
6818impl ObjectView {}
6819#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6820pub struct ObjectListHandle(pub(crate) super::tree::CstNodeId);
6821impl NonTerminalHandle for ObjectListHandle {
6822 type View = Option<ObjectListView>;
6823 fn node_id(&self) -> CstNodeId {
6824 self.0
6825 }
6826 fn new_with_visit<F: CstFacade, E>(
6827 index: CstNodeId,
6828 tree: &F,
6829 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6830 ) -> Result<Self, CstConstructError<E>> {
6831 tree.collect_nodes(
6832 index,
6833 [NodeKind::NonTerminal(NonTerminalKind::ObjectList)],
6834 |[index], visit| Ok((Self(index), visit)),
6835 visit_ignored,
6836 )
6837 }
6838 fn kind(&self) -> NonTerminalKind {
6839 NonTerminalKind::ObjectList
6840 }
6841 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6842 &self,
6843 tree: &F,
6844 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6845 visit_ignored: &'v mut V,
6846 ) -> Result<O, CstConstructError<E>> {
6847 if tree.has_no_children(self.0) {
6848 return Ok(visit(None, visit_ignored).0);
6849 }
6850 tree.collect_nodes(
6851 self.0,
6852 [
6853 NodeKind::NonTerminal(NonTerminalKind::Keys),
6854 NodeKind::NonTerminal(NonTerminalKind::MapBind),
6855 NodeKind::NonTerminal(NonTerminalKind::Value),
6856 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0),
6857 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
6858 ],
6859 |[keys, map_bind, value, object_opt_0, object_list], visit_ignored| {
6860 Ok(visit(
6861 Some(ObjectListView {
6862 keys: KeysHandle(keys),
6863 map_bind: MapBindHandle(map_bind),
6864 value: ValueHandle(value),
6865 object_opt_0: ObjectOpt0Handle(object_opt_0),
6866 object_list: ObjectListHandle(object_list),
6867 }),
6868 visit_ignored,
6869 ))
6870 },
6871 visit_ignored,
6872 )
6873 }
6874}
6875#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6876pub struct ObjectListView {
6877 pub keys: KeysHandle,
6878 pub map_bind: MapBindHandle,
6879 pub value: ValueHandle,
6880 pub object_opt_0: ObjectOpt0Handle,
6881 pub object_list: ObjectListHandle,
6882}
6883impl<F: CstFacade> RecursiveView<F> for ObjectListView {
6884 type Item = ObjectListItem;
6885 fn get_all_with_visit<E>(
6886 &self,
6887 tree: &F,
6888 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6889 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
6890 let mut items = Vec::new();
6891 let mut current_view = Some(*self);
6892 while let Some(item) = current_view {
6893 let Self {
6894 keys,
6895 map_bind,
6896 value,
6897 object_opt_0,
6898 ..
6899 } = item;
6900 items.push(ObjectListItem {
6901 keys,
6902 map_bind,
6903 value,
6904 object_opt_0,
6905 });
6906 item.object_list.get_view_with_visit(
6907 tree,
6908 |view, visit_ignored| {
6909 current_view = view;
6910 ((), visit_ignored)
6911 },
6912 visit_ignored,
6913 )?;
6914 }
6915 Ok(items)
6916 }
6917}
6918#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6919pub struct ObjectListItem {
6920 pub keys: KeysHandle,
6921 pub map_bind: MapBindHandle,
6922 pub value: ValueHandle,
6923 pub object_opt_0: ObjectOpt0Handle,
6924}
6925#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6926pub struct ObjectOptHandle(pub(crate) super::tree::CstNodeId);
6927impl NonTerminalHandle for ObjectOptHandle {
6928 type View = Option<ObjectOptView>;
6929 fn node_id(&self) -> CstNodeId {
6930 self.0
6931 }
6932 fn new_with_visit<F: CstFacade, E>(
6933 index: CstNodeId,
6934 tree: &F,
6935 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6936 ) -> Result<Self, CstConstructError<E>> {
6937 tree.collect_nodes(
6938 index,
6939 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt)],
6940 |[index], visit| Ok((Self(index), visit)),
6941 visit_ignored,
6942 )
6943 }
6944 fn kind(&self) -> NonTerminalKind {
6945 NonTerminalKind::ObjectOpt
6946 }
6947 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6948 &self,
6949 tree: &F,
6950 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6951 visit_ignored: &'v mut V,
6952 ) -> Result<O, CstConstructError<E>> {
6953 if tree.has_no_children(self.0) {
6954 return Ok(visit(None, visit_ignored).0);
6955 }
6956 tree.collect_nodes(
6957 self.0,
6958 [
6959 NodeKind::NonTerminal(NonTerminalKind::ValueBinding),
6960 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1),
6961 ],
6962 |[value_binding, object_opt_1], visit_ignored| {
6963 Ok(visit(
6964 Some(ObjectOptView {
6965 value_binding: ValueBindingHandle(value_binding),
6966 object_opt_1: ObjectOpt1Handle(object_opt_1),
6967 }),
6968 visit_ignored,
6969 ))
6970 },
6971 visit_ignored,
6972 )
6973 }
6974}
6975#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6976pub struct ObjectOptView {
6977 pub value_binding: ValueBindingHandle,
6978 pub object_opt_1: ObjectOpt1Handle,
6979}
6980#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6981pub struct ObjectOpt0Handle(pub(crate) super::tree::CstNodeId);
6982impl NonTerminalHandle for ObjectOpt0Handle {
6983 type View = Option<CommaHandle>;
6984 fn node_id(&self) -> CstNodeId {
6985 self.0
6986 }
6987 fn new_with_visit<F: CstFacade, E>(
6988 index: CstNodeId,
6989 tree: &F,
6990 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6991 ) -> Result<Self, CstConstructError<E>> {
6992 tree.collect_nodes(
6993 index,
6994 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0)],
6995 |[index], visit| Ok((Self(index), visit)),
6996 visit_ignored,
6997 )
6998 }
6999 fn kind(&self) -> NonTerminalKind {
7000 NonTerminalKind::ObjectOpt0
7001 }
7002 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7003 &self,
7004 tree: &F,
7005 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7006 visit_ignored: &'v mut V,
7007 ) -> Result<O, CstConstructError<E>> {
7008 if tree.has_no_children(self.0) {
7009 return Ok(visit(None, visit_ignored).0);
7010 }
7011 Ok(visit(
7012 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
7013 visit_ignored,
7014 )
7015 .0)
7016 }
7017}
7018#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7019pub struct ObjectOpt1Handle(pub(crate) super::tree::CstNodeId);
7020impl NonTerminalHandle for ObjectOpt1Handle {
7021 type View = Option<CommaHandle>;
7022 fn node_id(&self) -> CstNodeId {
7023 self.0
7024 }
7025 fn new_with_visit<F: CstFacade, E>(
7026 index: CstNodeId,
7027 tree: &F,
7028 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7029 ) -> Result<Self, CstConstructError<E>> {
7030 tree.collect_nodes(
7031 index,
7032 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1)],
7033 |[index], visit| Ok((Self(index), visit)),
7034 visit_ignored,
7035 )
7036 }
7037 fn kind(&self) -> NonTerminalKind {
7038 NonTerminalKind::ObjectOpt1
7039 }
7040 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7041 &self,
7042 tree: &F,
7043 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7044 visit_ignored: &'v mut V,
7045 ) -> Result<O, CstConstructError<E>> {
7046 if tree.has_no_children(self.0) {
7047 return Ok(visit(None, visit_ignored).0);
7048 }
7049 Ok(visit(
7050 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
7051 visit_ignored,
7052 )
7053 .0)
7054 }
7055}
7056#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7057pub struct RParenHandle(pub(crate) super::tree::CstNodeId);
7058impl NonTerminalHandle for RParenHandle {
7059 type View = RParenView;
7060 fn node_id(&self) -> CstNodeId {
7061 self.0
7062 }
7063 fn new_with_visit<F: CstFacade, E>(
7064 index: CstNodeId,
7065 tree: &F,
7066 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7067 ) -> Result<Self, CstConstructError<E>> {
7068 tree.collect_nodes(
7069 index,
7070 [NodeKind::NonTerminal(NonTerminalKind::RParen)],
7071 |[index], visit| Ok((Self(index), visit)),
7072 visit_ignored,
7073 )
7074 }
7075 fn kind(&self) -> NonTerminalKind {
7076 NonTerminalKind::RParen
7077 }
7078 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7079 &self,
7080 tree: &F,
7081 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7082 visit_ignored: &'v mut V,
7083 ) -> Result<O, CstConstructError<E>> {
7084 tree.collect_nodes(
7085 self.0,
7086 [NodeKind::Terminal(TerminalKind::RParen)],
7087 |[r_paren], visit_ignored| {
7088 Ok(visit(
7089 RParenView {
7090 r_paren: RParen(r_paren),
7091 },
7092 visit_ignored,
7093 ))
7094 },
7095 visit_ignored,
7096 )
7097 }
7098}
7099#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7100pub struct RParenView {
7101 pub r_paren: RParen,
7102}
7103impl RParenView {}
7104#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7105pub struct RootBindingHandle(pub(crate) super::tree::CstNodeId);
7106impl NonTerminalHandle for RootBindingHandle {
7107 type View = RootBindingView;
7108 fn node_id(&self) -> CstNodeId {
7109 self.0
7110 }
7111 fn new_with_visit<F: CstFacade, E>(
7112 index: CstNodeId,
7113 tree: &F,
7114 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7115 ) -> Result<Self, CstConstructError<E>> {
7116 tree.collect_nodes(
7117 index,
7118 [NodeKind::NonTerminal(NonTerminalKind::RootBinding)],
7119 |[index], visit| Ok((Self(index), visit)),
7120 visit_ignored,
7121 )
7122 }
7123 fn kind(&self) -> NonTerminalKind {
7124 NonTerminalKind::RootBinding
7125 }
7126 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7127 &self,
7128 tree: &F,
7129 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7130 visit_ignored: &'v mut V,
7131 ) -> Result<O, CstConstructError<E>> {
7132 let mut children = tree.children(self.0);
7133 let Some(child) = children.next() else {
7134 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7135 };
7136 let Some(child_data) = tree.node_data(child) else {
7137 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7138 };
7139 let variant = match child_data.node_kind() {
7140 NodeKind::NonTerminal(NonTerminalKind::RootValueBinding) => {
7141 RootBindingView::RootValueBinding(RootValueBindingHandle(child))
7142 }
7143 NodeKind::NonTerminal(NonTerminalKind::RootTextBinding) => {
7144 RootBindingView::RootTextBinding(RootTextBindingHandle(child))
7145 }
7146 _ => {
7147 return Err(ViewConstructionError::UnexpectedNode {
7148 node: child,
7149 data: child_data,
7150 expected_kind: child_data.node_kind(),
7151 });
7152 }
7153 };
7154 let (result, _visit) = visit(variant, visit_ignored);
7155 if let Some(extra_child) = children.next() {
7156 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7157 }
7158 Ok(result)
7159 }
7160}
7161#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7162pub enum RootBindingView {
7163 RootValueBinding(RootValueBindingHandle),
7164 RootTextBinding(RootTextBindingHandle),
7165}
7166impl RootBindingView {}
7167#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7168pub struct RootTextBindingHandle(pub(crate) super::tree::CstNodeId);
7169impl NonTerminalHandle for RootTextBindingHandle {
7170 type View = RootTextBindingView;
7171 fn node_id(&self) -> CstNodeId {
7172 self.0
7173 }
7174 fn new_with_visit<F: CstFacade, E>(
7175 index: CstNodeId,
7176 tree: &F,
7177 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7178 ) -> Result<Self, CstConstructError<E>> {
7179 tree.collect_nodes(
7180 index,
7181 [NodeKind::NonTerminal(NonTerminalKind::RootTextBinding)],
7182 |[index], visit| Ok((Self(index), visit)),
7183 visit_ignored,
7184 )
7185 }
7186 fn kind(&self) -> NonTerminalKind {
7187 NonTerminalKind::RootTextBinding
7188 }
7189 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7190 &self,
7191 tree: &F,
7192 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7193 visit_ignored: &'v mut V,
7194 ) -> Result<O, CstConstructError<E>> {
7195 tree.collect_nodes(
7196 self.0,
7197 [
7198 NodeKind::NonTerminal(NonTerminalKind::NewlineTextStart),
7199 NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt),
7200 NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt0),
7201 NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt1),
7202 ],
7203 |[
7204 newline_text_start,
7205 root_text_binding_opt,
7206 root_text_binding_opt_0,
7207 root_text_binding_opt_1,
7208 ],
7209 visit_ignored| {
7210 Ok(visit(
7211 RootTextBindingView {
7212 newline_text_start: NewlineTextStartHandle(newline_text_start),
7213 root_text_binding_opt: RootTextBindingOptHandle(root_text_binding_opt),
7214 root_text_binding_opt_0: RootTextBindingOpt0Handle(root_text_binding_opt_0),
7215 root_text_binding_opt_1: RootTextBindingOpt1Handle(root_text_binding_opt_1),
7216 },
7217 visit_ignored,
7218 ))
7219 },
7220 visit_ignored,
7221 )
7222 }
7223}
7224#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7225pub struct RootTextBindingView {
7226 pub newline_text_start: NewlineTextStartHandle,
7227 pub root_text_binding_opt: RootTextBindingOptHandle,
7228 pub root_text_binding_opt_0: RootTextBindingOpt0Handle,
7229 pub root_text_binding_opt_1: RootTextBindingOpt1Handle,
7230}
7231impl RootTextBindingView {}
7232#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7233pub struct RootTextBindingOptHandle(pub(crate) super::tree::CstNodeId);
7234impl NonTerminalHandle for RootTextBindingOptHandle {
7235 type View = Option<WsHandle>;
7236 fn node_id(&self) -> CstNodeId {
7237 self.0
7238 }
7239 fn new_with_visit<F: CstFacade, E>(
7240 index: CstNodeId,
7241 tree: &F,
7242 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7243 ) -> Result<Self, CstConstructError<E>> {
7244 tree.collect_nodes(
7245 index,
7246 [NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt)],
7247 |[index], visit| Ok((Self(index), visit)),
7248 visit_ignored,
7249 )
7250 }
7251 fn kind(&self) -> NonTerminalKind {
7252 NonTerminalKind::RootTextBindingOpt
7253 }
7254 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7255 &self,
7256 tree: &F,
7257 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7258 visit_ignored: &'v mut V,
7259 ) -> Result<O, CstConstructError<E>> {
7260 if tree.has_no_children(self.0) {
7261 return Ok(visit(None, visit_ignored).0);
7262 }
7263 Ok(visit(
7264 Some(WsHandle::new_with_visit(self.0, tree, visit_ignored)?),
7265 visit_ignored,
7266 )
7267 .0)
7268 }
7269}
7270#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7271pub struct RootTextBindingOpt0Handle(pub(crate) super::tree::CstNodeId);
7272impl NonTerminalHandle for RootTextBindingOpt0Handle {
7273 type View = Option<TextHandle>;
7274 fn node_id(&self) -> CstNodeId {
7275 self.0
7276 }
7277 fn new_with_visit<F: CstFacade, E>(
7278 index: CstNodeId,
7279 tree: &F,
7280 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7281 ) -> Result<Self, CstConstructError<E>> {
7282 tree.collect_nodes(
7283 index,
7284 [NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt0)],
7285 |[index], visit| Ok((Self(index), visit)),
7286 visit_ignored,
7287 )
7288 }
7289 fn kind(&self) -> NonTerminalKind {
7290 NonTerminalKind::RootTextBindingOpt0
7291 }
7292 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7293 &self,
7294 tree: &F,
7295 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7296 visit_ignored: &'v mut V,
7297 ) -> Result<O, CstConstructError<E>> {
7298 if tree.has_no_children(self.0) {
7299 return Ok(visit(None, visit_ignored).0);
7300 }
7301 Ok(visit(
7302 Some(TextHandle::new_with_visit(self.0, tree, visit_ignored)?),
7303 visit_ignored,
7304 )
7305 .0)
7306 }
7307}
7308#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7309pub struct RootTextBindingOpt1Handle(pub(crate) super::tree::CstNodeId);
7310impl NonTerminalHandle for RootTextBindingOpt1Handle {
7311 type View = Option<GrammarNewlineHandle>;
7312 fn node_id(&self) -> CstNodeId {
7313 self.0
7314 }
7315 fn new_with_visit<F: CstFacade, E>(
7316 index: CstNodeId,
7317 tree: &F,
7318 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7319 ) -> Result<Self, CstConstructError<E>> {
7320 tree.collect_nodes(
7321 index,
7322 [NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt1)],
7323 |[index], visit| Ok((Self(index), visit)),
7324 visit_ignored,
7325 )
7326 }
7327 fn kind(&self) -> NonTerminalKind {
7328 NonTerminalKind::RootTextBindingOpt1
7329 }
7330 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7331 &self,
7332 tree: &F,
7333 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7334 visit_ignored: &'v mut V,
7335 ) -> Result<O, CstConstructError<E>> {
7336 if tree.has_no_children(self.0) {
7337 return Ok(visit(None, visit_ignored).0);
7338 }
7339 Ok(visit(
7340 Some(GrammarNewlineHandle::new_with_visit(
7341 self.0,
7342 tree,
7343 visit_ignored,
7344 )?),
7345 visit_ignored,
7346 )
7347 .0)
7348 }
7349}
7350#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7351pub struct RootValueBindingHandle(pub(crate) super::tree::CstNodeId);
7352impl NonTerminalHandle for RootValueBindingHandle {
7353 type View = RootValueBindingView;
7354 fn node_id(&self) -> CstNodeId {
7355 self.0
7356 }
7357 fn new_with_visit<F: CstFacade, E>(
7358 index: CstNodeId,
7359 tree: &F,
7360 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7361 ) -> Result<Self, CstConstructError<E>> {
7362 tree.collect_nodes(
7363 index,
7364 [NodeKind::NonTerminal(NonTerminalKind::RootValueBinding)],
7365 |[index], visit| Ok((Self(index), visit)),
7366 visit_ignored,
7367 )
7368 }
7369 fn kind(&self) -> NonTerminalKind {
7370 NonTerminalKind::RootValueBinding
7371 }
7372 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7373 &self,
7374 tree: &F,
7375 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7376 visit_ignored: &'v mut V,
7377 ) -> Result<O, CstConstructError<E>> {
7378 tree.collect_nodes(
7379 self.0,
7380 [
7381 NodeKind::NonTerminal(NonTerminalKind::NewlineBind),
7382 NodeKind::NonTerminal(NonTerminalKind::Value),
7383 ],
7384 |[newline_bind, value], visit_ignored| {
7385 Ok(visit(
7386 RootValueBindingView {
7387 newline_bind: NewlineBindHandle(newline_bind),
7388 value: ValueHandle(value),
7389 },
7390 visit_ignored,
7391 ))
7392 },
7393 visit_ignored,
7394 )
7395 }
7396}
7397#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7398pub struct RootValueBindingView {
7399 pub newline_bind: NewlineBindHandle,
7400 pub value: ValueHandle,
7401}
7402impl RootValueBindingView {}
7403#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7404pub struct SQuoteHandle(pub(crate) super::tree::CstNodeId);
7405impl NonTerminalHandle for SQuoteHandle {
7406 type View = SQuoteView;
7407 fn node_id(&self) -> CstNodeId {
7408 self.0
7409 }
7410 fn new_with_visit<F: CstFacade, E>(
7411 index: CstNodeId,
7412 tree: &F,
7413 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7414 ) -> Result<Self, CstConstructError<E>> {
7415 tree.collect_nodes(
7416 index,
7417 [NodeKind::NonTerminal(NonTerminalKind::SQuote)],
7418 |[index], visit| Ok((Self(index), visit)),
7419 visit_ignored,
7420 )
7421 }
7422 fn kind(&self) -> NonTerminalKind {
7423 NonTerminalKind::SQuote
7424 }
7425 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7426 &self,
7427 tree: &F,
7428 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7429 visit_ignored: &'v mut V,
7430 ) -> Result<O, CstConstructError<E>> {
7431 tree.collect_nodes(
7432 self.0,
7433 [NodeKind::Terminal(TerminalKind::SQuote)],
7434 |[s_quote], visit_ignored| {
7435 Ok(visit(
7436 SQuoteView {
7437 s_quote: SQuote(s_quote),
7438 },
7439 visit_ignored,
7440 ))
7441 },
7442 visit_ignored,
7443 )
7444 }
7445}
7446#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7447pub struct SQuoteView {
7448 pub s_quote: SQuote,
7449}
7450impl SQuoteView {}
7451#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7452pub struct SectionHandle(pub(crate) super::tree::CstNodeId);
7453impl NonTerminalHandle for SectionHandle {
7454 type View = SectionView;
7455 fn node_id(&self) -> CstNodeId {
7456 self.0
7457 }
7458 fn new_with_visit<F: CstFacade, E>(
7459 index: CstNodeId,
7460 tree: &F,
7461 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7462 ) -> Result<Self, CstConstructError<E>> {
7463 tree.collect_nodes(
7464 index,
7465 [NodeKind::NonTerminal(NonTerminalKind::Section)],
7466 |[index], visit| Ok((Self(index), visit)),
7467 visit_ignored,
7468 )
7469 }
7470 fn kind(&self) -> NonTerminalKind {
7471 NonTerminalKind::Section
7472 }
7473 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7474 &self,
7475 tree: &F,
7476 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7477 visit_ignored: &'v mut V,
7478 ) -> Result<O, CstConstructError<E>> {
7479 tree.collect_nodes(
7480 self.0,
7481 [
7482 NodeKind::NonTerminal(NonTerminalKind::At),
7483 NodeKind::NonTerminal(NonTerminalKind::Keys),
7484 NodeKind::NonTerminal(NonTerminalKind::SectionBody),
7485 ],
7486 |[at, keys, section_body], visit_ignored| {
7487 Ok(visit(
7488 SectionView {
7489 at: AtHandle(at),
7490 keys: KeysHandle(keys),
7491 section_body: SectionBodyHandle(section_body),
7492 },
7493 visit_ignored,
7494 ))
7495 },
7496 visit_ignored,
7497 )
7498 }
7499}
7500#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7501pub struct SectionView {
7502 pub at: AtHandle,
7503 pub keys: KeysHandle,
7504 pub section_body: SectionBodyHandle,
7505}
7506impl SectionView {}
7507#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7508pub struct SectionBindingHandle(pub(crate) super::tree::CstNodeId);
7509impl NonTerminalHandle for SectionBindingHandle {
7510 type View = SectionBindingView;
7511 fn node_id(&self) -> CstNodeId {
7512 self.0
7513 }
7514 fn new_with_visit<F: CstFacade, E>(
7515 index: CstNodeId,
7516 tree: &F,
7517 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7518 ) -> Result<Self, CstConstructError<E>> {
7519 tree.collect_nodes(
7520 index,
7521 [NodeKind::NonTerminal(NonTerminalKind::SectionBinding)],
7522 |[index], visit| Ok((Self(index), visit)),
7523 visit_ignored,
7524 )
7525 }
7526 fn kind(&self) -> NonTerminalKind {
7527 NonTerminalKind::SectionBinding
7528 }
7529 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7530 &self,
7531 tree: &F,
7532 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7533 visit_ignored: &'v mut V,
7534 ) -> Result<O, CstConstructError<E>> {
7535 tree.collect_nodes(
7536 self.0,
7537 [
7538 NodeKind::NonTerminal(NonTerminalKind::Begin),
7539 NodeKind::NonTerminal(NonTerminalKind::Eure),
7540 NodeKind::NonTerminal(NonTerminalKind::End),
7541 ],
7542 |[begin, eure, end], visit_ignored| {
7543 Ok(visit(
7544 SectionBindingView {
7545 begin: BeginHandle(begin),
7546 eure: EureHandle(eure),
7547 end: EndHandle(end),
7548 },
7549 visit_ignored,
7550 ))
7551 },
7552 visit_ignored,
7553 )
7554 }
7555}
7556#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7557pub struct SectionBindingView {
7558 pub begin: BeginHandle,
7559 pub eure: EureHandle,
7560 pub end: EndHandle,
7561}
7562impl SectionBindingView {}
7563#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7564pub struct SectionBodyHandle(pub(crate) super::tree::CstNodeId);
7565impl NonTerminalHandle for SectionBodyHandle {
7566 type View = SectionBodyView;
7567 fn node_id(&self) -> CstNodeId {
7568 self.0
7569 }
7570 fn new_with_visit<F: CstFacade, E>(
7571 index: CstNodeId,
7572 tree: &F,
7573 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7574 ) -> Result<Self, CstConstructError<E>> {
7575 tree.collect_nodes(
7576 index,
7577 [NodeKind::NonTerminal(NonTerminalKind::SectionBody)],
7578 |[index], visit| Ok((Self(index), visit)),
7579 visit_ignored,
7580 )
7581 }
7582 fn kind(&self) -> NonTerminalKind {
7583 NonTerminalKind::SectionBody
7584 }
7585 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7586 &self,
7587 tree: &F,
7588 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7589 visit_ignored: &'v mut V,
7590 ) -> Result<O, CstConstructError<E>> {
7591 let mut children = tree.children(self.0);
7592 let Some(child) = children.next() else {
7593 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7594 };
7595 let Some(child_data) = tree.node_data(child) else {
7596 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7597 };
7598 let variant = match child_data.node_kind() {
7599 NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt) => {
7600 SectionBodyView::SectionBodyOpt(SectionBodyOptHandle(child))
7601 }
7602 NodeKind::NonTerminal(NonTerminalKind::BlockBody) => {
7603 SectionBodyView::BlockBody(BlockBodyHandle(child))
7604 }
7605 _ => {
7606 return Err(ViewConstructionError::UnexpectedNode {
7607 node: child,
7608 data: child_data,
7609 expected_kind: child_data.node_kind(),
7610 });
7611 }
7612 };
7613 let (result, _visit) = visit(variant, visit_ignored);
7614 if let Some(extra_child) = children.next() {
7615 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7616 }
7617 Ok(result)
7618 }
7619}
7620#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7621pub enum SectionBodyView {
7622 SectionBodyOpt(SectionBodyOptHandle),
7623 BlockBody(BlockBodyHandle),
7624}
7625impl SectionBodyView {}
7626#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7627pub struct SectionBodyOptHandle(pub(crate) super::tree::CstNodeId);
7628impl NonTerminalHandle for SectionBodyOptHandle {
7629 type View = Option<FlatBodyHandle>;
7630 fn node_id(&self) -> CstNodeId {
7631 self.0
7632 }
7633 fn new_with_visit<F: CstFacade, E>(
7634 index: CstNodeId,
7635 tree: &F,
7636 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7637 ) -> Result<Self, CstConstructError<E>> {
7638 tree.collect_nodes(
7639 index,
7640 [NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt)],
7641 |[index], visit| Ok((Self(index), visit)),
7642 visit_ignored,
7643 )
7644 }
7645 fn kind(&self) -> NonTerminalKind {
7646 NonTerminalKind::SectionBodyOpt
7647 }
7648 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7649 &self,
7650 tree: &F,
7651 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7652 visit_ignored: &'v mut V,
7653 ) -> Result<O, CstConstructError<E>> {
7654 if tree.has_no_children(self.0) {
7655 return Ok(visit(None, visit_ignored).0);
7656 }
7657 Ok(visit(
7658 Some(FlatBodyHandle::new_with_visit(self.0, tree, visit_ignored)?),
7659 visit_ignored,
7660 )
7661 .0)
7662 }
7663}
7664#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7665pub struct SectionHeadHandle(pub(crate) super::tree::CstNodeId);
7666impl NonTerminalHandle for SectionHeadHandle {
7667 type View = SectionHeadView;
7668 fn node_id(&self) -> CstNodeId {
7669 self.0
7670 }
7671 fn new_with_visit<F: CstFacade, E>(
7672 index: CstNodeId,
7673 tree: &F,
7674 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7675 ) -> Result<Self, CstConstructError<E>> {
7676 tree.collect_nodes(
7677 index,
7678 [NodeKind::NonTerminal(NonTerminalKind::SectionHead)],
7679 |[index], visit| Ok((Self(index), visit)),
7680 visit_ignored,
7681 )
7682 }
7683 fn kind(&self) -> NonTerminalKind {
7684 NonTerminalKind::SectionHead
7685 }
7686 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7687 &self,
7688 tree: &F,
7689 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7690 visit_ignored: &'v mut V,
7691 ) -> Result<O, CstConstructError<E>> {
7692 let mut children = tree.children(self.0);
7693 let Some(child) = children.next() else {
7694 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7695 };
7696 let Some(child_data) = tree.node_data(child) else {
7697 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7698 };
7699 let variant = match child_data.node_kind() {
7700 NodeKind::NonTerminal(NonTerminalKind::RootBinding) => {
7701 SectionHeadView::RootBinding(RootBindingHandle(child))
7702 }
7703 NodeKind::NonTerminal(NonTerminalKind::NewlineHead) => {
7704 SectionHeadView::NewlineHead(NewlineHeadHandle(child))
7705 }
7706 _ => {
7707 return Err(ViewConstructionError::UnexpectedNode {
7708 node: child,
7709 data: child_data,
7710 expected_kind: child_data.node_kind(),
7711 });
7712 }
7713 };
7714 let (result, _visit) = visit(variant, visit_ignored);
7715 if let Some(extra_child) = children.next() {
7716 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7717 }
7718 Ok(result)
7719 }
7720}
7721#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7722pub enum SectionHeadView {
7723 RootBinding(RootBindingHandle),
7724 NewlineHead(NewlineHeadHandle),
7725}
7726impl SectionHeadView {}
7727#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7728pub struct StrHandle(pub(crate) super::tree::CstNodeId);
7729impl NonTerminalHandle for StrHandle {
7730 type View = StrView;
7731 fn node_id(&self) -> CstNodeId {
7732 self.0
7733 }
7734 fn new_with_visit<F: CstFacade, E>(
7735 index: CstNodeId,
7736 tree: &F,
7737 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7738 ) -> Result<Self, CstConstructError<E>> {
7739 tree.collect_nodes(
7740 index,
7741 [NodeKind::NonTerminal(NonTerminalKind::Str)],
7742 |[index], visit| Ok((Self(index), visit)),
7743 visit_ignored,
7744 )
7745 }
7746 fn kind(&self) -> NonTerminalKind {
7747 NonTerminalKind::Str
7748 }
7749 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7750 &self,
7751 tree: &F,
7752 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7753 visit_ignored: &'v mut V,
7754 ) -> Result<O, CstConstructError<E>> {
7755 tree.collect_nodes(
7756 self.0,
7757 [NodeKind::Terminal(TerminalKind::Str)],
7758 |[str], visit_ignored| Ok(visit(StrView { str: Str(str) }, visit_ignored)),
7759 visit_ignored,
7760 )
7761 }
7762}
7763#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7764pub struct StrView {
7765 pub str: Str,
7766}
7767impl StrView {}
7768#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7769pub struct StringHandle(pub(crate) super::tree::CstNodeId);
7770impl NonTerminalHandle for StringHandle {
7771 type View = StringView;
7772 fn node_id(&self) -> CstNodeId {
7773 self.0
7774 }
7775 fn new_with_visit<F: CstFacade, E>(
7776 index: CstNodeId,
7777 tree: &F,
7778 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7779 ) -> Result<Self, CstConstructError<E>> {
7780 tree.collect_nodes(
7781 index,
7782 [NodeKind::NonTerminal(NonTerminalKind::String)],
7783 |[index], visit| Ok((Self(index), visit)),
7784 visit_ignored,
7785 )
7786 }
7787 fn kind(&self) -> NonTerminalKind {
7788 NonTerminalKind::String
7789 }
7790 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7791 &self,
7792 tree: &F,
7793 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7794 visit_ignored: &'v mut V,
7795 ) -> Result<O, CstConstructError<E>> {
7796 let mut children = tree.children(self.0);
7797 let Some(child) = children.next() else {
7798 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7799 };
7800 let Some(child_data) = tree.node_data(child) else {
7801 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7802 };
7803 let variant = match child_data.node_kind() {
7804 NodeKind::NonTerminal(NonTerminalKind::Str) => StringView::Str(StrHandle(child)),
7805 NodeKind::NonTerminal(NonTerminalKind::LitStr) => {
7806 StringView::LitStr(LitStrHandle(child))
7807 }
7808 NodeKind::NonTerminal(NonTerminalKind::LitStr1) => {
7809 StringView::LitStr1(LitStr1Handle(child))
7810 }
7811 NodeKind::NonTerminal(NonTerminalKind::LitStr2) => {
7812 StringView::LitStr2(LitStr2Handle(child))
7813 }
7814 NodeKind::NonTerminal(NonTerminalKind::LitStr3) => {
7815 StringView::LitStr3(LitStr3Handle(child))
7816 }
7817 _ => {
7818 return Err(ViewConstructionError::UnexpectedNode {
7819 node: child,
7820 data: child_data,
7821 expected_kind: child_data.node_kind(),
7822 });
7823 }
7824 };
7825 let (result, _visit) = visit(variant, visit_ignored);
7826 if let Some(extra_child) = children.next() {
7827 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7828 }
7829 Ok(result)
7830 }
7831}
7832#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7833pub enum StringView {
7834 Str(StrHandle),
7835 LitStr(LitStrHandle),
7836 LitStr1(LitStr1Handle),
7837 LitStr2(LitStr2Handle),
7838 LitStr3(LitStr3Handle),
7839}
7840impl StringView {}
7841#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7842pub struct StringsHandle(pub(crate) super::tree::CstNodeId);
7843impl NonTerminalHandle for StringsHandle {
7844 type View = StringsView;
7845 fn node_id(&self) -> CstNodeId {
7846 self.0
7847 }
7848 fn new_with_visit<F: CstFacade, E>(
7849 index: CstNodeId,
7850 tree: &F,
7851 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7852 ) -> Result<Self, CstConstructError<E>> {
7853 tree.collect_nodes(
7854 index,
7855 [NodeKind::NonTerminal(NonTerminalKind::Strings)],
7856 |[index], visit| Ok((Self(index), visit)),
7857 visit_ignored,
7858 )
7859 }
7860 fn kind(&self) -> NonTerminalKind {
7861 NonTerminalKind::Strings
7862 }
7863 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7864 &self,
7865 tree: &F,
7866 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7867 visit_ignored: &'v mut V,
7868 ) -> Result<O, CstConstructError<E>> {
7869 tree.collect_nodes(
7870 self.0,
7871 [
7872 NodeKind::NonTerminal(NonTerminalKind::String),
7873 NodeKind::NonTerminal(NonTerminalKind::StringsList),
7874 ],
7875 |[string, strings_list], visit_ignored| {
7876 Ok(visit(
7877 StringsView {
7878 string: StringHandle(string),
7879 strings_list: StringsListHandle(strings_list),
7880 },
7881 visit_ignored,
7882 ))
7883 },
7884 visit_ignored,
7885 )
7886 }
7887}
7888#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7889pub struct StringsView {
7890 pub string: StringHandle,
7891 pub strings_list: StringsListHandle,
7892}
7893impl StringsView {}
7894#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7895pub struct StringsListHandle(pub(crate) super::tree::CstNodeId);
7896impl NonTerminalHandle for StringsListHandle {
7897 type View = Option<StringsListView>;
7898 fn node_id(&self) -> CstNodeId {
7899 self.0
7900 }
7901 fn new_with_visit<F: CstFacade, E>(
7902 index: CstNodeId,
7903 tree: &F,
7904 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7905 ) -> Result<Self, CstConstructError<E>> {
7906 tree.collect_nodes(
7907 index,
7908 [NodeKind::NonTerminal(NonTerminalKind::StringsList)],
7909 |[index], visit| Ok((Self(index), visit)),
7910 visit_ignored,
7911 )
7912 }
7913 fn kind(&self) -> NonTerminalKind {
7914 NonTerminalKind::StringsList
7915 }
7916 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7917 &self,
7918 tree: &F,
7919 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7920 visit_ignored: &'v mut V,
7921 ) -> Result<O, CstConstructError<E>> {
7922 if tree.has_no_children(self.0) {
7923 return Ok(visit(None, visit_ignored).0);
7924 }
7925 tree.collect_nodes(
7926 self.0,
7927 [
7928 NodeKind::NonTerminal(NonTerminalKind::Continue),
7929 NodeKind::NonTerminal(NonTerminalKind::String),
7930 NodeKind::NonTerminal(NonTerminalKind::StringsList),
7931 ],
7932 |[r#continue, string, strings_list], visit_ignored| {
7933 Ok(visit(
7934 Some(StringsListView {
7935 r#continue: ContinueHandle(r#continue),
7936 string: StringHandle(string),
7937 strings_list: StringsListHandle(strings_list),
7938 }),
7939 visit_ignored,
7940 ))
7941 },
7942 visit_ignored,
7943 )
7944 }
7945}
7946#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7947pub struct StringsListView {
7948 pub r#continue: ContinueHandle,
7949 pub string: StringHandle,
7950 pub strings_list: StringsListHandle,
7951}
7952impl<F: CstFacade> RecursiveView<F> for StringsListView {
7953 type Item = StringsListItem;
7954 fn get_all_with_visit<E>(
7955 &self,
7956 tree: &F,
7957 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7958 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
7959 let mut items = Vec::new();
7960 let mut current_view = Some(*self);
7961 while let Some(item) = current_view {
7962 let Self {
7963 r#continue, string, ..
7964 } = item;
7965 items.push(StringsListItem { r#continue, string });
7966 item.strings_list.get_view_with_visit(
7967 tree,
7968 |view, visit_ignored| {
7969 current_view = view;
7970 ((), visit_ignored)
7971 },
7972 visit_ignored,
7973 )?;
7974 }
7975 Ok(items)
7976 }
7977}
7978#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7979pub struct StringsListItem {
7980 pub r#continue: ContinueHandle,
7981 pub string: StringHandle,
7982}
7983#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7984pub struct TextHandle(pub(crate) super::tree::CstNodeId);
7985impl NonTerminalHandle for TextHandle {
7986 type View = TextView;
7987 fn node_id(&self) -> CstNodeId {
7988 self.0
7989 }
7990 fn new_with_visit<F: CstFacade, E>(
7991 index: CstNodeId,
7992 tree: &F,
7993 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7994 ) -> Result<Self, CstConstructError<E>> {
7995 tree.collect_nodes(
7996 index,
7997 [NodeKind::NonTerminal(NonTerminalKind::Text)],
7998 |[index], visit| Ok((Self(index), visit)),
7999 visit_ignored,
8000 )
8001 }
8002 fn kind(&self) -> NonTerminalKind {
8003 NonTerminalKind::Text
8004 }
8005 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8006 &self,
8007 tree: &F,
8008 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8009 visit_ignored: &'v mut V,
8010 ) -> Result<O, CstConstructError<E>> {
8011 tree.collect_nodes(
8012 self.0,
8013 [NodeKind::Terminal(TerminalKind::Text)],
8014 |[text], visit_ignored| Ok(visit(TextView { text: Text(text) }, visit_ignored)),
8015 visit_ignored,
8016 )
8017 }
8018}
8019#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8020pub struct TextView {
8021 pub text: Text,
8022}
8023impl TextView {}
8024#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8025pub struct TextBindingHandle(pub(crate) super::tree::CstNodeId);
8026impl NonTerminalHandle for TextBindingHandle {
8027 type View = TextBindingView;
8028 fn node_id(&self) -> CstNodeId {
8029 self.0
8030 }
8031 fn new_with_visit<F: CstFacade, E>(
8032 index: CstNodeId,
8033 tree: &F,
8034 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8035 ) -> Result<Self, CstConstructError<E>> {
8036 tree.collect_nodes(
8037 index,
8038 [NodeKind::NonTerminal(NonTerminalKind::TextBinding)],
8039 |[index], visit| Ok((Self(index), visit)),
8040 visit_ignored,
8041 )
8042 }
8043 fn kind(&self) -> NonTerminalKind {
8044 NonTerminalKind::TextBinding
8045 }
8046 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8047 &self,
8048 tree: &F,
8049 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8050 visit_ignored: &'v mut V,
8051 ) -> Result<O, CstConstructError<E>> {
8052 tree.collect_nodes(
8053 self.0,
8054 [
8055 NodeKind::NonTerminal(NonTerminalKind::TextStart),
8056 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt),
8057 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0),
8058 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt1),
8059 ],
8060 |[
8061 text_start,
8062 text_binding_opt,
8063 text_binding_opt_0,
8064 text_binding_opt_1,
8065 ],
8066 visit_ignored| {
8067 Ok(visit(
8068 TextBindingView {
8069 text_start: TextStartHandle(text_start),
8070 text_binding_opt: TextBindingOptHandle(text_binding_opt),
8071 text_binding_opt_0: TextBindingOpt0Handle(text_binding_opt_0),
8072 text_binding_opt_1: TextBindingOpt1Handle(text_binding_opt_1),
8073 },
8074 visit_ignored,
8075 ))
8076 },
8077 visit_ignored,
8078 )
8079 }
8080}
8081#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8082pub struct TextBindingView {
8083 pub text_start: TextStartHandle,
8084 pub text_binding_opt: TextBindingOptHandle,
8085 pub text_binding_opt_0: TextBindingOpt0Handle,
8086 pub text_binding_opt_1: TextBindingOpt1Handle,
8087}
8088impl TextBindingView {}
8089#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8090pub struct TextBindingOptHandle(pub(crate) super::tree::CstNodeId);
8091impl NonTerminalHandle for TextBindingOptHandle {
8092 type View = Option<WsHandle>;
8093 fn node_id(&self) -> CstNodeId {
8094 self.0
8095 }
8096 fn new_with_visit<F: CstFacade, E>(
8097 index: CstNodeId,
8098 tree: &F,
8099 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8100 ) -> Result<Self, CstConstructError<E>> {
8101 tree.collect_nodes(
8102 index,
8103 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt)],
8104 |[index], visit| Ok((Self(index), visit)),
8105 visit_ignored,
8106 )
8107 }
8108 fn kind(&self) -> NonTerminalKind {
8109 NonTerminalKind::TextBindingOpt
8110 }
8111 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8112 &self,
8113 tree: &F,
8114 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8115 visit_ignored: &'v mut V,
8116 ) -> Result<O, CstConstructError<E>> {
8117 if tree.has_no_children(self.0) {
8118 return Ok(visit(None, visit_ignored).0);
8119 }
8120 Ok(visit(
8121 Some(WsHandle::new_with_visit(self.0, tree, visit_ignored)?),
8122 visit_ignored,
8123 )
8124 .0)
8125 }
8126}
8127#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8128pub struct TextBindingOpt0Handle(pub(crate) super::tree::CstNodeId);
8129impl NonTerminalHandle for TextBindingOpt0Handle {
8130 type View = Option<TextHandle>;
8131 fn node_id(&self) -> CstNodeId {
8132 self.0
8133 }
8134 fn new_with_visit<F: CstFacade, E>(
8135 index: CstNodeId,
8136 tree: &F,
8137 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8138 ) -> Result<Self, CstConstructError<E>> {
8139 tree.collect_nodes(
8140 index,
8141 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0)],
8142 |[index], visit| Ok((Self(index), visit)),
8143 visit_ignored,
8144 )
8145 }
8146 fn kind(&self) -> NonTerminalKind {
8147 NonTerminalKind::TextBindingOpt0
8148 }
8149 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8150 &self,
8151 tree: &F,
8152 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8153 visit_ignored: &'v mut V,
8154 ) -> Result<O, CstConstructError<E>> {
8155 if tree.has_no_children(self.0) {
8156 return Ok(visit(None, visit_ignored).0);
8157 }
8158 Ok(visit(
8159 Some(TextHandle::new_with_visit(self.0, tree, visit_ignored)?),
8160 visit_ignored,
8161 )
8162 .0)
8163 }
8164}
8165#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8166pub struct TextBindingOpt1Handle(pub(crate) super::tree::CstNodeId);
8167impl NonTerminalHandle for TextBindingOpt1Handle {
8168 type View = Option<GrammarNewlineHandle>;
8169 fn node_id(&self) -> CstNodeId {
8170 self.0
8171 }
8172 fn new_with_visit<F: CstFacade, E>(
8173 index: CstNodeId,
8174 tree: &F,
8175 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8176 ) -> Result<Self, CstConstructError<E>> {
8177 tree.collect_nodes(
8178 index,
8179 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt1)],
8180 |[index], visit| Ok((Self(index), visit)),
8181 visit_ignored,
8182 )
8183 }
8184 fn kind(&self) -> NonTerminalKind {
8185 NonTerminalKind::TextBindingOpt1
8186 }
8187 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8188 &self,
8189 tree: &F,
8190 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8191 visit_ignored: &'v mut V,
8192 ) -> Result<O, CstConstructError<E>> {
8193 if tree.has_no_children(self.0) {
8194 return Ok(visit(None, visit_ignored).0);
8195 }
8196 Ok(visit(
8197 Some(GrammarNewlineHandle::new_with_visit(
8198 self.0,
8199 tree,
8200 visit_ignored,
8201 )?),
8202 visit_ignored,
8203 )
8204 .0)
8205 }
8206}
8207#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8208pub struct TextStartHandle(pub(crate) super::tree::CstNodeId);
8209impl NonTerminalHandle for TextStartHandle {
8210 type View = TextStartView;
8211 fn node_id(&self) -> CstNodeId {
8212 self.0
8213 }
8214 fn new_with_visit<F: CstFacade, E>(
8215 index: CstNodeId,
8216 tree: &F,
8217 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8218 ) -> Result<Self, CstConstructError<E>> {
8219 tree.collect_nodes(
8220 index,
8221 [NodeKind::NonTerminal(NonTerminalKind::TextStart)],
8222 |[index], visit| Ok((Self(index), visit)),
8223 visit_ignored,
8224 )
8225 }
8226 fn kind(&self) -> NonTerminalKind {
8227 NonTerminalKind::TextStart
8228 }
8229 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8230 &self,
8231 tree: &F,
8232 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8233 visit_ignored: &'v mut V,
8234 ) -> Result<O, CstConstructError<E>> {
8235 tree.collect_nodes(
8236 self.0,
8237 [NodeKind::Terminal(TerminalKind::TextStart)],
8238 |[text_start], visit_ignored| {
8239 Ok(visit(
8240 TextStartView {
8241 text_start: TextStart(text_start),
8242 },
8243 visit_ignored,
8244 ))
8245 },
8246 visit_ignored,
8247 )
8248 }
8249}
8250#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8251pub struct TextStartView {
8252 pub text_start: TextStart,
8253}
8254impl TextStartView {}
8255#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8256pub struct TopLevelBindingHandle(pub(crate) super::tree::CstNodeId);
8257impl NonTerminalHandle for TopLevelBindingHandle {
8258 type View = TopLevelBindingView;
8259 fn node_id(&self) -> CstNodeId {
8260 self.0
8261 }
8262 fn new_with_visit<F: CstFacade, E>(
8263 index: CstNodeId,
8264 tree: &F,
8265 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8266 ) -> Result<Self, CstConstructError<E>> {
8267 tree.collect_nodes(
8268 index,
8269 [NodeKind::NonTerminal(NonTerminalKind::TopLevelBinding)],
8270 |[index], visit| Ok((Self(index), visit)),
8271 visit_ignored,
8272 )
8273 }
8274 fn kind(&self) -> NonTerminalKind {
8275 NonTerminalKind::TopLevelBinding
8276 }
8277 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8278 &self,
8279 tree: &F,
8280 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8281 visit_ignored: &'v mut V,
8282 ) -> Result<O, CstConstructError<E>> {
8283 let mut children = tree.children(self.0);
8284 let Some(child) = children.next() else {
8285 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
8286 };
8287 let Some(child_data) = tree.node_data(child) else {
8288 return Err(ViewConstructionError::NodeIdNotFound { node: child });
8289 };
8290 let variant = match child_data.node_kind() {
8291 NodeKind::NonTerminal(NonTerminalKind::ValueBinding) => {
8292 TopLevelBindingView::ValueBinding(ValueBindingHandle(child))
8293 }
8294 NodeKind::NonTerminal(NonTerminalKind::TextBinding) => {
8295 TopLevelBindingView::TextBinding(TextBindingHandle(child))
8296 }
8297 _ => {
8298 return Err(ViewConstructionError::UnexpectedNode {
8299 node: child,
8300 data: child_data,
8301 expected_kind: child_data.node_kind(),
8302 });
8303 }
8304 };
8305 let (result, _visit) = visit(variant, visit_ignored);
8306 if let Some(extra_child) = children.next() {
8307 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
8308 }
8309 Ok(result)
8310 }
8311}
8312#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8313pub enum TopLevelBindingView {
8314 ValueBinding(ValueBindingHandle),
8315 TextBinding(TextBindingHandle),
8316}
8317impl TopLevelBindingView {}
8318#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8319pub struct TrueHandle(pub(crate) super::tree::CstNodeId);
8320impl NonTerminalHandle for TrueHandle {
8321 type View = TrueView;
8322 fn node_id(&self) -> CstNodeId {
8323 self.0
8324 }
8325 fn new_with_visit<F: CstFacade, E>(
8326 index: CstNodeId,
8327 tree: &F,
8328 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8329 ) -> Result<Self, CstConstructError<E>> {
8330 tree.collect_nodes(
8331 index,
8332 [NodeKind::NonTerminal(NonTerminalKind::True)],
8333 |[index], visit| Ok((Self(index), visit)),
8334 visit_ignored,
8335 )
8336 }
8337 fn kind(&self) -> NonTerminalKind {
8338 NonTerminalKind::True
8339 }
8340 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8341 &self,
8342 tree: &F,
8343 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8344 visit_ignored: &'v mut V,
8345 ) -> Result<O, CstConstructError<E>> {
8346 tree.collect_nodes(
8347 self.0,
8348 [NodeKind::Terminal(TerminalKind::True)],
8349 |[r#true], visit_ignored| {
8350 Ok(visit(
8351 TrueView {
8352 r#true: True(r#true),
8353 },
8354 visit_ignored,
8355 ))
8356 },
8357 visit_ignored,
8358 )
8359 }
8360}
8361#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8362pub struct TrueView {
8363 pub r#true: True,
8364}
8365impl TrueView {}
8366#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8367pub struct TupleHandle(pub(crate) super::tree::CstNodeId);
8368impl NonTerminalHandle for TupleHandle {
8369 type View = TupleView;
8370 fn node_id(&self) -> CstNodeId {
8371 self.0
8372 }
8373 fn new_with_visit<F: CstFacade, E>(
8374 index: CstNodeId,
8375 tree: &F,
8376 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8377 ) -> Result<Self, CstConstructError<E>> {
8378 tree.collect_nodes(
8379 index,
8380 [NodeKind::NonTerminal(NonTerminalKind::Tuple)],
8381 |[index], visit| Ok((Self(index), visit)),
8382 visit_ignored,
8383 )
8384 }
8385 fn kind(&self) -> NonTerminalKind {
8386 NonTerminalKind::Tuple
8387 }
8388 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8389 &self,
8390 tree: &F,
8391 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8392 visit_ignored: &'v mut V,
8393 ) -> Result<O, CstConstructError<E>> {
8394 tree.collect_nodes(
8395 self.0,
8396 [
8397 NodeKind::NonTerminal(NonTerminalKind::LParen),
8398 NodeKind::NonTerminal(NonTerminalKind::TupleOpt),
8399 NodeKind::NonTerminal(NonTerminalKind::RParen),
8400 ],
8401 |[l_paren, tuple_opt, r_paren], visit_ignored| {
8402 Ok(visit(
8403 TupleView {
8404 l_paren: LParenHandle(l_paren),
8405 tuple_opt: TupleOptHandle(tuple_opt),
8406 r_paren: RParenHandle(r_paren),
8407 },
8408 visit_ignored,
8409 ))
8410 },
8411 visit_ignored,
8412 )
8413 }
8414}
8415#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8416pub struct TupleView {
8417 pub l_paren: LParenHandle,
8418 pub tuple_opt: TupleOptHandle,
8419 pub r_paren: RParenHandle,
8420}
8421impl TupleView {}
8422#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8423pub struct TupleElementsHandle(pub(crate) super::tree::CstNodeId);
8424impl NonTerminalHandle for TupleElementsHandle {
8425 type View = TupleElementsView;
8426 fn node_id(&self) -> CstNodeId {
8427 self.0
8428 }
8429 fn new_with_visit<F: CstFacade, E>(
8430 index: CstNodeId,
8431 tree: &F,
8432 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8433 ) -> Result<Self, CstConstructError<E>> {
8434 tree.collect_nodes(
8435 index,
8436 [NodeKind::NonTerminal(NonTerminalKind::TupleElements)],
8437 |[index], visit| Ok((Self(index), visit)),
8438 visit_ignored,
8439 )
8440 }
8441 fn kind(&self) -> NonTerminalKind {
8442 NonTerminalKind::TupleElements
8443 }
8444 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8445 &self,
8446 tree: &F,
8447 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8448 visit_ignored: &'v mut V,
8449 ) -> Result<O, CstConstructError<E>> {
8450 tree.collect_nodes(
8451 self.0,
8452 [
8453 NodeKind::NonTerminal(NonTerminalKind::Value),
8454 NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt),
8455 ],
8456 |[value, tuple_elements_opt], visit_ignored| {
8457 Ok(visit(
8458 TupleElementsView {
8459 value: ValueHandle(value),
8460 tuple_elements_opt: TupleElementsOptHandle(tuple_elements_opt),
8461 },
8462 visit_ignored,
8463 ))
8464 },
8465 visit_ignored,
8466 )
8467 }
8468}
8469#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8470pub struct TupleElementsView {
8471 pub value: ValueHandle,
8472 pub tuple_elements_opt: TupleElementsOptHandle,
8473}
8474impl TupleElementsView {}
8475#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8476pub struct TupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
8477impl NonTerminalHandle for TupleElementsOptHandle {
8478 type View = Option<TupleElementsTailHandle>;
8479 fn node_id(&self) -> CstNodeId {
8480 self.0
8481 }
8482 fn new_with_visit<F: CstFacade, E>(
8483 index: CstNodeId,
8484 tree: &F,
8485 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8486 ) -> Result<Self, CstConstructError<E>> {
8487 tree.collect_nodes(
8488 index,
8489 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt)],
8490 |[index], visit| Ok((Self(index), visit)),
8491 visit_ignored,
8492 )
8493 }
8494 fn kind(&self) -> NonTerminalKind {
8495 NonTerminalKind::TupleElementsOpt
8496 }
8497 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8498 &self,
8499 tree: &F,
8500 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8501 visit_ignored: &'v mut V,
8502 ) -> Result<O, CstConstructError<E>> {
8503 if tree.has_no_children(self.0) {
8504 return Ok(visit(None, visit_ignored).0);
8505 }
8506 Ok(visit(
8507 Some(TupleElementsTailHandle::new_with_visit(
8508 self.0,
8509 tree,
8510 visit_ignored,
8511 )?),
8512 visit_ignored,
8513 )
8514 .0)
8515 }
8516}
8517#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8518pub struct TupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
8519impl NonTerminalHandle for TupleElementsTailHandle {
8520 type View = TupleElementsTailView;
8521 fn node_id(&self) -> CstNodeId {
8522 self.0
8523 }
8524 fn new_with_visit<F: CstFacade, E>(
8525 index: CstNodeId,
8526 tree: &F,
8527 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8528 ) -> Result<Self, CstConstructError<E>> {
8529 tree.collect_nodes(
8530 index,
8531 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTail)],
8532 |[index], visit| Ok((Self(index), visit)),
8533 visit_ignored,
8534 )
8535 }
8536 fn kind(&self) -> NonTerminalKind {
8537 NonTerminalKind::TupleElementsTail
8538 }
8539 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8540 &self,
8541 tree: &F,
8542 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8543 visit_ignored: &'v mut V,
8544 ) -> Result<O, CstConstructError<E>> {
8545 tree.collect_nodes(
8546 self.0,
8547 [
8548 NodeKind::NonTerminal(NonTerminalKind::Comma),
8549 NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt),
8550 ],
8551 |[comma, tuple_elements_tail_opt], visit_ignored| {
8552 Ok(visit(
8553 TupleElementsTailView {
8554 comma: CommaHandle(comma),
8555 tuple_elements_tail_opt: TupleElementsTailOptHandle(
8556 tuple_elements_tail_opt,
8557 ),
8558 },
8559 visit_ignored,
8560 ))
8561 },
8562 visit_ignored,
8563 )
8564 }
8565}
8566#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8567pub struct TupleElementsTailView {
8568 pub comma: CommaHandle,
8569 pub tuple_elements_tail_opt: TupleElementsTailOptHandle,
8570}
8571impl TupleElementsTailView {}
8572#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8573pub struct TupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
8574impl NonTerminalHandle for TupleElementsTailOptHandle {
8575 type View = Option<TupleElementsHandle>;
8576 fn node_id(&self) -> CstNodeId {
8577 self.0
8578 }
8579 fn new_with_visit<F: CstFacade, E>(
8580 index: CstNodeId,
8581 tree: &F,
8582 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8583 ) -> Result<Self, CstConstructError<E>> {
8584 tree.collect_nodes(
8585 index,
8586 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt)],
8587 |[index], visit| Ok((Self(index), visit)),
8588 visit_ignored,
8589 )
8590 }
8591 fn kind(&self) -> NonTerminalKind {
8592 NonTerminalKind::TupleElementsTailOpt
8593 }
8594 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8595 &self,
8596 tree: &F,
8597 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8598 visit_ignored: &'v mut V,
8599 ) -> Result<O, CstConstructError<E>> {
8600 if tree.has_no_children(self.0) {
8601 return Ok(visit(None, visit_ignored).0);
8602 }
8603 Ok(visit(
8604 Some(TupleElementsHandle::new_with_visit(
8605 self.0,
8606 tree,
8607 visit_ignored,
8608 )?),
8609 visit_ignored,
8610 )
8611 .0)
8612 }
8613}
8614#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8615pub struct TupleIndexHandle(pub(crate) super::tree::CstNodeId);
8616impl NonTerminalHandle for TupleIndexHandle {
8617 type View = TupleIndexView;
8618 fn node_id(&self) -> CstNodeId {
8619 self.0
8620 }
8621 fn new_with_visit<F: CstFacade, E>(
8622 index: CstNodeId,
8623 tree: &F,
8624 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8625 ) -> Result<Self, CstConstructError<E>> {
8626 tree.collect_nodes(
8627 index,
8628 [NodeKind::NonTerminal(NonTerminalKind::TupleIndex)],
8629 |[index], visit| Ok((Self(index), visit)),
8630 visit_ignored,
8631 )
8632 }
8633 fn kind(&self) -> NonTerminalKind {
8634 NonTerminalKind::TupleIndex
8635 }
8636 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8637 &self,
8638 tree: &F,
8639 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8640 visit_ignored: &'v mut V,
8641 ) -> Result<O, CstConstructError<E>> {
8642 tree.collect_nodes(
8643 self.0,
8644 [
8645 NodeKind::Terminal(TerminalKind::Hash),
8646 NodeKind::NonTerminal(NonTerminalKind::Integer),
8647 ],
8648 |[hash, integer], visit_ignored| {
8649 Ok(visit(
8650 TupleIndexView {
8651 hash: Hash(hash),
8652 integer: IntegerHandle(integer),
8653 },
8654 visit_ignored,
8655 ))
8656 },
8657 visit_ignored,
8658 )
8659 }
8660}
8661#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8662pub struct TupleIndexView {
8663 pub hash: Hash,
8664 pub integer: IntegerHandle,
8665}
8666impl TupleIndexView {}
8667#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8668pub struct TupleOptHandle(pub(crate) super::tree::CstNodeId);
8669impl NonTerminalHandle for TupleOptHandle {
8670 type View = Option<TupleElementsHandle>;
8671 fn node_id(&self) -> CstNodeId {
8672 self.0
8673 }
8674 fn new_with_visit<F: CstFacade, E>(
8675 index: CstNodeId,
8676 tree: &F,
8677 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8678 ) -> Result<Self, CstConstructError<E>> {
8679 tree.collect_nodes(
8680 index,
8681 [NodeKind::NonTerminal(NonTerminalKind::TupleOpt)],
8682 |[index], visit| Ok((Self(index), visit)),
8683 visit_ignored,
8684 )
8685 }
8686 fn kind(&self) -> NonTerminalKind {
8687 NonTerminalKind::TupleOpt
8688 }
8689 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8690 &self,
8691 tree: &F,
8692 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8693 visit_ignored: &'v mut V,
8694 ) -> Result<O, CstConstructError<E>> {
8695 if tree.has_no_children(self.0) {
8696 return Ok(visit(None, visit_ignored).0);
8697 }
8698 Ok(visit(
8699 Some(TupleElementsHandle::new_with_visit(
8700 self.0,
8701 tree,
8702 visit_ignored,
8703 )?),
8704 visit_ignored,
8705 )
8706 .0)
8707 }
8708}
8709#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8710pub struct ValueHandle(pub(crate) super::tree::CstNodeId);
8711impl NonTerminalHandle for ValueHandle {
8712 type View = ValueView;
8713 fn node_id(&self) -> CstNodeId {
8714 self.0
8715 }
8716 fn new_with_visit<F: CstFacade, E>(
8717 index: CstNodeId,
8718 tree: &F,
8719 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8720 ) -> Result<Self, CstConstructError<E>> {
8721 tree.collect_nodes(
8722 index,
8723 [NodeKind::NonTerminal(NonTerminalKind::Value)],
8724 |[index], visit| Ok((Self(index), visit)),
8725 visit_ignored,
8726 )
8727 }
8728 fn kind(&self) -> NonTerminalKind {
8729 NonTerminalKind::Value
8730 }
8731 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8732 &self,
8733 tree: &F,
8734 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8735 visit_ignored: &'v mut V,
8736 ) -> Result<O, CstConstructError<E>> {
8737 let mut children = tree.children(self.0);
8738 let Some(child) = children.next() else {
8739 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
8740 };
8741 let Some(child_data) = tree.node_data(child) else {
8742 return Err(ViewConstructionError::NodeIdNotFound { node: child });
8743 };
8744 let variant = match child_data.node_kind() {
8745 NodeKind::NonTerminal(NonTerminalKind::Object) => {
8746 ValueView::Object(ObjectHandle(child))
8747 }
8748 NodeKind::NonTerminal(NonTerminalKind::Array) => ValueView::Array(ArrayHandle(child)),
8749 NodeKind::NonTerminal(NonTerminalKind::Tuple) => ValueView::Tuple(TupleHandle(child)),
8750 NodeKind::NonTerminal(NonTerminalKind::Number) => {
8751 ValueView::Number(NumberHandle(child))
8752 }
8753 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
8754 ValueView::Boolean(BooleanHandle(child))
8755 }
8756 NodeKind::NonTerminal(NonTerminalKind::Null) => ValueView::Null(NullHandle(child)),
8757 NodeKind::NonTerminal(NonTerminalKind::Strings) => {
8758 ValueView::Strings(StringsHandle(child))
8759 }
8760 NodeKind::NonTerminal(NonTerminalKind::Hole) => ValueView::Hole(HoleHandle(child)),
8761 NodeKind::NonTerminal(NonTerminalKind::CodeBlock) => {
8762 ValueView::CodeBlock(CodeBlockHandle(child))
8763 }
8764 NodeKind::NonTerminal(NonTerminalKind::InlineCode) => {
8765 ValueView::InlineCode(InlineCodeHandle(child))
8766 }
8767 _ => {
8768 return Err(ViewConstructionError::UnexpectedNode {
8769 node: child,
8770 data: child_data,
8771 expected_kind: child_data.node_kind(),
8772 });
8773 }
8774 };
8775 let (result, _visit) = visit(variant, visit_ignored);
8776 if let Some(extra_child) = children.next() {
8777 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
8778 }
8779 Ok(result)
8780 }
8781}
8782#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8783pub enum ValueView {
8784 Object(ObjectHandle),
8785 Array(ArrayHandle),
8786 Tuple(TupleHandle),
8787 Number(NumberHandle),
8788 Boolean(BooleanHandle),
8789 Null(NullHandle),
8790 Strings(StringsHandle),
8791 Hole(HoleHandle),
8792 CodeBlock(CodeBlockHandle),
8793 InlineCode(InlineCodeHandle),
8794}
8795impl ValueView {}
8796#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8797pub struct ValueBindingHandle(pub(crate) super::tree::CstNodeId);
8798impl NonTerminalHandle for ValueBindingHandle {
8799 type View = ValueBindingView;
8800 fn node_id(&self) -> CstNodeId {
8801 self.0
8802 }
8803 fn new_with_visit<F: CstFacade, E>(
8804 index: CstNodeId,
8805 tree: &F,
8806 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8807 ) -> Result<Self, CstConstructError<E>> {
8808 tree.collect_nodes(
8809 index,
8810 [NodeKind::NonTerminal(NonTerminalKind::ValueBinding)],
8811 |[index], visit| Ok((Self(index), visit)),
8812 visit_ignored,
8813 )
8814 }
8815 fn kind(&self) -> NonTerminalKind {
8816 NonTerminalKind::ValueBinding
8817 }
8818 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8819 &self,
8820 tree: &F,
8821 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8822 visit_ignored: &'v mut V,
8823 ) -> Result<O, CstConstructError<E>> {
8824 tree.collect_nodes(
8825 self.0,
8826 [
8827 NodeKind::NonTerminal(NonTerminalKind::Bind),
8828 NodeKind::NonTerminal(NonTerminalKind::Value),
8829 ],
8830 |[bind, value], visit_ignored| {
8831 Ok(visit(
8832 ValueBindingView {
8833 bind: BindHandle(bind),
8834 value: ValueHandle(value),
8835 },
8836 visit_ignored,
8837 ))
8838 },
8839 visit_ignored,
8840 )
8841 }
8842}
8843#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8844pub struct ValueBindingView {
8845 pub bind: BindHandle,
8846 pub value: ValueHandle,
8847}
8848impl ValueBindingView {}
8849#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8850pub struct WsHandle(pub(crate) super::tree::CstNodeId);
8851impl NonTerminalHandle for WsHandle {
8852 type View = WsView;
8853 fn node_id(&self) -> CstNodeId {
8854 self.0
8855 }
8856 fn new_with_visit<F: CstFacade, E>(
8857 index: CstNodeId,
8858 tree: &F,
8859 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8860 ) -> Result<Self, CstConstructError<E>> {
8861 tree.collect_nodes(
8862 index,
8863 [NodeKind::NonTerminal(NonTerminalKind::Ws)],
8864 |[index], visit| Ok((Self(index), visit)),
8865 visit_ignored,
8866 )
8867 }
8868 fn kind(&self) -> NonTerminalKind {
8869 NonTerminalKind::Ws
8870 }
8871 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8872 &self,
8873 tree: &F,
8874 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8875 visit_ignored: &'v mut V,
8876 ) -> Result<O, CstConstructError<E>> {
8877 tree.collect_nodes(
8878 self.0,
8879 [NodeKind::Terminal(TerminalKind::Ws)],
8880 |[ws], visit_ignored| Ok(visit(WsView { ws: Ws(ws) }, visit_ignored)),
8881 visit_ignored,
8882 )
8883 }
8884}
8885#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8886pub struct WsView {
8887 pub ws: Ws,
8888}
8889impl WsView {}
8890#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8891pub struct RootHandle(pub(crate) super::tree::CstNodeId);
8892impl NonTerminalHandle for RootHandle {
8893 type View = RootView;
8894 fn node_id(&self) -> CstNodeId {
8895 self.0
8896 }
8897 fn new_with_visit<F: CstFacade, E>(
8898 index: CstNodeId,
8899 tree: &F,
8900 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8901 ) -> Result<Self, CstConstructError<E>> {
8902 tree.collect_nodes(
8903 index,
8904 [NodeKind::NonTerminal(NonTerminalKind::Root)],
8905 |[index], visit| Ok((Self(index), visit)),
8906 visit_ignored,
8907 )
8908 }
8909 fn kind(&self) -> NonTerminalKind {
8910 NonTerminalKind::Root
8911 }
8912 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8913 &self,
8914 tree: &F,
8915 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8916 visit_ignored: &'v mut V,
8917 ) -> Result<O, CstConstructError<E>> {
8918 tree.collect_nodes(
8919 self.0,
8920 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
8921 |[eure], visit_ignored| {
8922 Ok(visit(
8923 RootView {
8924 eure: EureHandle(eure),
8925 },
8926 visit_ignored,
8927 ))
8928 },
8929 visit_ignored,
8930 )
8931 }
8932}
8933#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8934pub struct RootView {
8935 pub eure: EureHandle,
8936}
8937impl RootView {}
8938#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8939pub struct NewLine(pub(crate) super::tree::CstNodeId);
8940impl TerminalHandle for NewLine {
8941 fn node_id(&self) -> CstNodeId {
8942 self.0
8943 }
8944 fn kind(&self) -> TerminalKind {
8945 TerminalKind::NewLine
8946 }
8947}
8948#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8949pub struct Whitespace(pub(crate) super::tree::CstNodeId);
8950impl TerminalHandle for Whitespace {
8951 fn node_id(&self) -> CstNodeId {
8952 self.0
8953 }
8954 fn kind(&self) -> TerminalKind {
8955 TerminalKind::Whitespace
8956 }
8957}
8958#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8959pub struct LineComment(pub(crate) super::tree::CstNodeId);
8960impl TerminalHandle for LineComment {
8961 fn node_id(&self) -> CstNodeId {
8962 self.0
8963 }
8964 fn kind(&self) -> TerminalKind {
8965 TerminalKind::LineComment
8966 }
8967}
8968#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8969pub struct BlockComment(pub(crate) super::tree::CstNodeId);
8970impl TerminalHandle for BlockComment {
8971 fn node_id(&self) -> CstNodeId {
8972 self.0
8973 }
8974 fn kind(&self) -> TerminalKind {
8975 TerminalKind::BlockComment
8976 }
8977}
8978#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8979pub struct Hash(pub(crate) super::tree::CstNodeId);
8980impl TerminalHandle for Hash {
8981 fn node_id(&self) -> CstNodeId {
8982 self.0
8983 }
8984 fn kind(&self) -> TerminalKind {
8985 TerminalKind::Hash
8986 }
8987}
8988#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8989pub struct MapBind(pub(crate) super::tree::CstNodeId);
8990impl TerminalHandle for MapBind {
8991 fn node_id(&self) -> CstNodeId {
8992 self.0
8993 }
8994 fn kind(&self) -> TerminalKind {
8995 TerminalKind::MapBind
8996 }
8997}
8998#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8999pub struct Integer(pub(crate) super::tree::CstNodeId);
9000impl TerminalHandle for Integer {
9001 fn node_id(&self) -> CstNodeId {
9002 self.0
9003 }
9004 fn kind(&self) -> TerminalKind {
9005 TerminalKind::Integer
9006 }
9007}
9008#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9009pub struct Float(pub(crate) super::tree::CstNodeId);
9010impl TerminalHandle for Float {
9011 fn node_id(&self) -> CstNodeId {
9012 self.0
9013 }
9014 fn kind(&self) -> TerminalKind {
9015 TerminalKind::Float
9016 }
9017}
9018#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9019pub struct Inf(pub(crate) super::tree::CstNodeId);
9020impl TerminalHandle for Inf {
9021 fn node_id(&self) -> CstNodeId {
9022 self.0
9023 }
9024 fn kind(&self) -> TerminalKind {
9025 TerminalKind::Inf
9026 }
9027}
9028#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9029pub struct NaN(pub(crate) super::tree::CstNodeId);
9030impl TerminalHandle for NaN {
9031 fn node_id(&self) -> CstNodeId {
9032 self.0
9033 }
9034 fn kind(&self) -> TerminalKind {
9035 TerminalKind::NaN
9036 }
9037}
9038#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9039pub struct True(pub(crate) super::tree::CstNodeId);
9040impl TerminalHandle for True {
9041 fn node_id(&self) -> CstNodeId {
9042 self.0
9043 }
9044 fn kind(&self) -> TerminalKind {
9045 TerminalKind::True
9046 }
9047}
9048#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9049pub struct False(pub(crate) super::tree::CstNodeId);
9050impl TerminalHandle for False {
9051 fn node_id(&self) -> CstNodeId {
9052 self.0
9053 }
9054 fn kind(&self) -> TerminalKind {
9055 TerminalKind::False
9056 }
9057}
9058#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9059pub struct Null(pub(crate) super::tree::CstNodeId);
9060impl TerminalHandle for Null {
9061 fn node_id(&self) -> CstNodeId {
9062 self.0
9063 }
9064 fn kind(&self) -> TerminalKind {
9065 TerminalKind::Null
9066 }
9067}
9068#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9069pub struct Hole(pub(crate) super::tree::CstNodeId);
9070impl TerminalHandle for Hole {
9071 fn node_id(&self) -> CstNodeId {
9072 self.0
9073 }
9074 fn kind(&self) -> TerminalKind {
9075 TerminalKind::Hole
9076 }
9077}
9078#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9079pub struct Str(pub(crate) super::tree::CstNodeId);
9080impl TerminalHandle for Str {
9081 fn node_id(&self) -> CstNodeId {
9082 self.0
9083 }
9084 fn kind(&self) -> TerminalKind {
9085 TerminalKind::Str
9086 }
9087}
9088#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9089pub struct LitStr(pub(crate) super::tree::CstNodeId);
9090impl TerminalHandle for LitStr {
9091 fn node_id(&self) -> CstNodeId {
9092 self.0
9093 }
9094 fn kind(&self) -> TerminalKind {
9095 TerminalKind::LitStr
9096 }
9097}
9098#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9099pub struct Text(pub(crate) super::tree::CstNodeId);
9100impl TerminalHandle for Text {
9101 fn node_id(&self) -> CstNodeId {
9102 self.0
9103 }
9104 fn kind(&self) -> TerminalKind {
9105 TerminalKind::Text
9106 }
9107}
9108#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9109pub struct InlineCode1(pub(crate) super::tree::CstNodeId);
9110impl TerminalHandle for InlineCode1 {
9111 fn node_id(&self) -> CstNodeId {
9112 self.0
9113 }
9114 fn kind(&self) -> TerminalKind {
9115 TerminalKind::InlineCode1
9116 }
9117}
9118#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9119pub struct LitStr3Start(pub(crate) super::tree::CstNodeId);
9120impl TerminalHandle for LitStr3Start {
9121 fn node_id(&self) -> CstNodeId {
9122 self.0
9123 }
9124 fn kind(&self) -> TerminalKind {
9125 TerminalKind::LitStr3Start
9126 }
9127}
9128#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9129pub struct LitStr2Start(pub(crate) super::tree::CstNodeId);
9130impl TerminalHandle for LitStr2Start {
9131 fn node_id(&self) -> CstNodeId {
9132 self.0
9133 }
9134 fn kind(&self) -> TerminalKind {
9135 TerminalKind::LitStr2Start
9136 }
9137}
9138#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9139pub struct LitStr1Start(pub(crate) super::tree::CstNodeId);
9140impl TerminalHandle for LitStr1Start {
9141 fn node_id(&self) -> CstNodeId {
9142 self.0
9143 }
9144 fn kind(&self) -> TerminalKind {
9145 TerminalKind::LitStr1Start
9146 }
9147}
9148#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9149pub struct DelimCodeStart3(pub(crate) super::tree::CstNodeId);
9150impl TerminalHandle for DelimCodeStart3 {
9151 fn node_id(&self) -> CstNodeId {
9152 self.0
9153 }
9154 fn kind(&self) -> TerminalKind {
9155 TerminalKind::DelimCodeStart3
9156 }
9157}
9158#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9159pub struct DelimCodeStart2(pub(crate) super::tree::CstNodeId);
9160impl TerminalHandle for DelimCodeStart2 {
9161 fn node_id(&self) -> CstNodeId {
9162 self.0
9163 }
9164 fn kind(&self) -> TerminalKind {
9165 TerminalKind::DelimCodeStart2
9166 }
9167}
9168#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9169pub struct DelimCodeStart1(pub(crate) super::tree::CstNodeId);
9170impl TerminalHandle for DelimCodeStart1 {
9171 fn node_id(&self) -> CstNodeId {
9172 self.0
9173 }
9174 fn kind(&self) -> TerminalKind {
9175 TerminalKind::DelimCodeStart1
9176 }
9177}
9178#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9179pub struct CodeBlockStart3(pub(crate) super::tree::CstNodeId);
9180impl TerminalHandle for CodeBlockStart3 {
9181 fn node_id(&self) -> CstNodeId {
9182 self.0
9183 }
9184 fn kind(&self) -> TerminalKind {
9185 TerminalKind::CodeBlockStart3
9186 }
9187}
9188#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9189pub struct CodeBlockStart4(pub(crate) super::tree::CstNodeId);
9190impl TerminalHandle for CodeBlockStart4 {
9191 fn node_id(&self) -> CstNodeId {
9192 self.0
9193 }
9194 fn kind(&self) -> TerminalKind {
9195 TerminalKind::CodeBlockStart4
9196 }
9197}
9198#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9199pub struct CodeBlockStart5(pub(crate) super::tree::CstNodeId);
9200impl TerminalHandle for CodeBlockStart5 {
9201 fn node_id(&self) -> CstNodeId {
9202 self.0
9203 }
9204 fn kind(&self) -> TerminalKind {
9205 TerminalKind::CodeBlockStart5
9206 }
9207}
9208#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9209pub struct CodeBlockStart6(pub(crate) super::tree::CstNodeId);
9210impl TerminalHandle for CodeBlockStart6 {
9211 fn node_id(&self) -> CstNodeId {
9212 self.0
9213 }
9214 fn kind(&self) -> TerminalKind {
9215 TerminalKind::CodeBlockStart6
9216 }
9217}
9218#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9219pub struct CodeBlockEnd3(pub(crate) super::tree::CstNodeId);
9220impl TerminalHandle for CodeBlockEnd3 {
9221 fn node_id(&self) -> CstNodeId {
9222 self.0
9223 }
9224 fn kind(&self) -> TerminalKind {
9225 TerminalKind::CodeBlockEnd3
9226 }
9227}
9228#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9229pub struct Backtick2(pub(crate) super::tree::CstNodeId);
9230impl TerminalHandle for Backtick2 {
9231 fn node_id(&self) -> CstNodeId {
9232 self.0
9233 }
9234 fn kind(&self) -> TerminalKind {
9235 TerminalKind::Backtick2
9236 }
9237}
9238#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9239pub struct CodeBlockEnd4(pub(crate) super::tree::CstNodeId);
9240impl TerminalHandle for CodeBlockEnd4 {
9241 fn node_id(&self) -> CstNodeId {
9242 self.0
9243 }
9244 fn kind(&self) -> TerminalKind {
9245 TerminalKind::CodeBlockEnd4
9246 }
9247}
9248#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9249pub struct Backtick3(pub(crate) super::tree::CstNodeId);
9250impl TerminalHandle for Backtick3 {
9251 fn node_id(&self) -> CstNodeId {
9252 self.0
9253 }
9254 fn kind(&self) -> TerminalKind {
9255 TerminalKind::Backtick3
9256 }
9257}
9258#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9259pub struct CodeBlockEnd5(pub(crate) super::tree::CstNodeId);
9260impl TerminalHandle for CodeBlockEnd5 {
9261 fn node_id(&self) -> CstNodeId {
9262 self.0
9263 }
9264 fn kind(&self) -> TerminalKind {
9265 TerminalKind::CodeBlockEnd5
9266 }
9267}
9268#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9269pub struct Backtick4(pub(crate) super::tree::CstNodeId);
9270impl TerminalHandle for Backtick4 {
9271 fn node_id(&self) -> CstNodeId {
9272 self.0
9273 }
9274 fn kind(&self) -> TerminalKind {
9275 TerminalKind::Backtick4
9276 }
9277}
9278#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9279pub struct CodeBlockEnd6(pub(crate) super::tree::CstNodeId);
9280impl TerminalHandle for CodeBlockEnd6 {
9281 fn node_id(&self) -> CstNodeId {
9282 self.0
9283 }
9284 fn kind(&self) -> TerminalKind {
9285 TerminalKind::CodeBlockEnd6
9286 }
9287}
9288#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9289pub struct Backtick5(pub(crate) super::tree::CstNodeId);
9290impl TerminalHandle for Backtick5 {
9291 fn node_id(&self) -> CstNodeId {
9292 self.0
9293 }
9294 fn kind(&self) -> TerminalKind {
9295 TerminalKind::Backtick5
9296 }
9297}
9298#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9299pub struct NoBacktick(pub(crate) super::tree::CstNodeId);
9300impl TerminalHandle for NoBacktick {
9301 fn node_id(&self) -> CstNodeId {
9302 self.0
9303 }
9304 fn kind(&self) -> TerminalKind {
9305 TerminalKind::NoBacktick
9306 }
9307}
9308#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9309pub struct LitStr3End(pub(crate) super::tree::CstNodeId);
9310impl TerminalHandle for LitStr3End {
9311 fn node_id(&self) -> CstNodeId {
9312 self.0
9313 }
9314 fn kind(&self) -> TerminalKind {
9315 TerminalKind::LitStr3End
9316 }
9317}
9318#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9319pub struct LitStr2End(pub(crate) super::tree::CstNodeId);
9320impl TerminalHandle for LitStr2End {
9321 fn node_id(&self) -> CstNodeId {
9322 self.0
9323 }
9324 fn kind(&self) -> TerminalKind {
9325 TerminalKind::LitStr2End
9326 }
9327}
9328#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9329pub struct LitStr1End(pub(crate) super::tree::CstNodeId);
9330impl TerminalHandle for LitStr1End {
9331 fn node_id(&self) -> CstNodeId {
9332 self.0
9333 }
9334 fn kind(&self) -> TerminalKind {
9335 TerminalKind::LitStr1End
9336 }
9337}
9338#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9339pub struct SQuote(pub(crate) super::tree::CstNodeId);
9340impl TerminalHandle for SQuote {
9341 fn node_id(&self) -> CstNodeId {
9342 self.0
9343 }
9344 fn kind(&self) -> TerminalKind {
9345 TerminalKind::SQuote
9346 }
9347}
9348#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9349pub struct NoSQuote(pub(crate) super::tree::CstNodeId);
9350impl TerminalHandle for NoSQuote {
9351 fn node_id(&self) -> CstNodeId {
9352 self.0
9353 }
9354 fn kind(&self) -> TerminalKind {
9355 TerminalKind::NoSQuote
9356 }
9357}
9358#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9359pub struct DelimCodeEnd3(pub(crate) super::tree::CstNodeId);
9360impl TerminalHandle for DelimCodeEnd3 {
9361 fn node_id(&self) -> CstNodeId {
9362 self.0
9363 }
9364 fn kind(&self) -> TerminalKind {
9365 TerminalKind::DelimCodeEnd3
9366 }
9367}
9368#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9369pub struct DelimCodeEnd2(pub(crate) super::tree::CstNodeId);
9370impl TerminalHandle for DelimCodeEnd2 {
9371 fn node_id(&self) -> CstNodeId {
9372 self.0
9373 }
9374 fn kind(&self) -> TerminalKind {
9375 TerminalKind::DelimCodeEnd2
9376 }
9377}
9378#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9379pub struct DelimCodeEnd1(pub(crate) super::tree::CstNodeId);
9380impl TerminalHandle for DelimCodeEnd1 {
9381 fn node_id(&self) -> CstNodeId {
9382 self.0
9383 }
9384 fn kind(&self) -> TerminalKind {
9385 TerminalKind::DelimCodeEnd1
9386 }
9387}
9388#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9389pub struct BacktickDelim(pub(crate) super::tree::CstNodeId);
9390impl TerminalHandle for BacktickDelim {
9391 fn node_id(&self) -> CstNodeId {
9392 self.0
9393 }
9394 fn kind(&self) -> TerminalKind {
9395 TerminalKind::BacktickDelim
9396 }
9397}
9398#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9399pub struct GrammarNewline(pub(crate) super::tree::CstNodeId);
9400impl TerminalHandle for GrammarNewline {
9401 fn node_id(&self) -> CstNodeId {
9402 self.0
9403 }
9404 fn kind(&self) -> TerminalKind {
9405 TerminalKind::GrammarNewline
9406 }
9407}
9408#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9409pub struct Ws(pub(crate) super::tree::CstNodeId);
9410impl TerminalHandle for Ws {
9411 fn node_id(&self) -> CstNodeId {
9412 self.0
9413 }
9414 fn kind(&self) -> TerminalKind {
9415 TerminalKind::Ws
9416 }
9417}
9418#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9419pub struct At(pub(crate) super::tree::CstNodeId);
9420impl TerminalHandle for At {
9421 fn node_id(&self) -> CstNodeId {
9422 self.0
9423 }
9424 fn kind(&self) -> TerminalKind {
9425 TerminalKind::At
9426 }
9427}
9428#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9429pub struct Dollar(pub(crate) super::tree::CstNodeId);
9430impl TerminalHandle for Dollar {
9431 fn node_id(&self) -> CstNodeId {
9432 self.0
9433 }
9434 fn kind(&self) -> TerminalKind {
9435 TerminalKind::Dollar
9436 }
9437}
9438#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9439pub struct Dot(pub(crate) super::tree::CstNodeId);
9440impl TerminalHandle for Dot {
9441 fn node_id(&self) -> CstNodeId {
9442 self.0
9443 }
9444 fn kind(&self) -> TerminalKind {
9445 TerminalKind::Dot
9446 }
9447}
9448#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9449pub struct LBrace(pub(crate) super::tree::CstNodeId);
9450impl TerminalHandle for LBrace {
9451 fn node_id(&self) -> CstNodeId {
9452 self.0
9453 }
9454 fn kind(&self) -> TerminalKind {
9455 TerminalKind::LBrace
9456 }
9457}
9458#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9459pub struct RBrace(pub(crate) super::tree::CstNodeId);
9460impl TerminalHandle for RBrace {
9461 fn node_id(&self) -> CstNodeId {
9462 self.0
9463 }
9464 fn kind(&self) -> TerminalKind {
9465 TerminalKind::RBrace
9466 }
9467}
9468#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9469pub struct LBracket(pub(crate) super::tree::CstNodeId);
9470impl TerminalHandle for LBracket {
9471 fn node_id(&self) -> CstNodeId {
9472 self.0
9473 }
9474 fn kind(&self) -> TerminalKind {
9475 TerminalKind::LBracket
9476 }
9477}
9478#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9479pub struct RBracket(pub(crate) super::tree::CstNodeId);
9480impl TerminalHandle for RBracket {
9481 fn node_id(&self) -> CstNodeId {
9482 self.0
9483 }
9484 fn kind(&self) -> TerminalKind {
9485 TerminalKind::RBracket
9486 }
9487}
9488#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9489pub struct LParen(pub(crate) super::tree::CstNodeId);
9490impl TerminalHandle for LParen {
9491 fn node_id(&self) -> CstNodeId {
9492 self.0
9493 }
9494 fn kind(&self) -> TerminalKind {
9495 TerminalKind::LParen
9496 }
9497}
9498#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9499pub struct RParen(pub(crate) super::tree::CstNodeId);
9500impl TerminalHandle for RParen {
9501 fn node_id(&self) -> CstNodeId {
9502 self.0
9503 }
9504 fn kind(&self) -> TerminalKind {
9505 TerminalKind::RParen
9506 }
9507}
9508#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9509pub struct NewlineBind(pub(crate) super::tree::CstNodeId);
9510impl TerminalHandle for NewlineBind {
9511 fn node_id(&self) -> CstNodeId {
9512 self.0
9513 }
9514 fn kind(&self) -> TerminalKind {
9515 TerminalKind::NewlineBind
9516 }
9517}
9518#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9519pub struct Bind(pub(crate) super::tree::CstNodeId);
9520impl TerminalHandle for Bind {
9521 fn node_id(&self) -> CstNodeId {
9522 self.0
9523 }
9524 fn kind(&self) -> TerminalKind {
9525 TerminalKind::Bind
9526 }
9527}
9528#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9529pub struct Comma(pub(crate) super::tree::CstNodeId);
9530impl TerminalHandle for Comma {
9531 fn node_id(&self) -> CstNodeId {
9532 self.0
9533 }
9534 fn kind(&self) -> TerminalKind {
9535 TerminalKind::Comma
9536 }
9537}
9538#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9539pub struct Esc(pub(crate) super::tree::CstNodeId);
9540impl TerminalHandle for Esc {
9541 fn node_id(&self) -> CstNodeId {
9542 self.0
9543 }
9544 fn kind(&self) -> TerminalKind {
9545 TerminalKind::Esc
9546 }
9547}
9548#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9549pub struct NewlineTextStart(pub(crate) super::tree::CstNodeId);
9550impl TerminalHandle for NewlineTextStart {
9551 fn node_id(&self) -> CstNodeId {
9552 self.0
9553 }
9554 fn kind(&self) -> TerminalKind {
9555 TerminalKind::NewlineTextStart
9556 }
9557}
9558#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9559pub struct TextStart(pub(crate) super::tree::CstNodeId);
9560impl TerminalHandle for TextStart {
9561 fn node_id(&self) -> CstNodeId {
9562 self.0
9563 }
9564 fn kind(&self) -> TerminalKind {
9565 TerminalKind::TextStart
9566 }
9567}
9568#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9569pub struct Ident(pub(crate) super::tree::CstNodeId);
9570impl TerminalHandle for Ident {
9571 fn node_id(&self) -> CstNodeId {
9572 self.0
9573 }
9574 fn kind(&self) -> TerminalKind {
9575 TerminalKind::Ident
9576 }
9577}