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 NodeKind::NonTerminal(NonTerminalKind::Hole) => KeyView::Hole(HoleHandle(child)),
4643 _ => {
4644 return Err(ViewConstructionError::UnexpectedNode {
4645 node: child,
4646 data: child_data,
4647 expected_kind: child_data.node_kind(),
4648 });
4649 }
4650 };
4651 let (result, _visit) = visit(variant, visit_ignored);
4652 if let Some(extra_child) = children.next() {
4653 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4654 }
4655 Ok(result)
4656 }
4657}
4658#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4659pub enum KeyView {
4660 KeyIdent(KeyIdentHandle),
4661 ExtensionNameSpace(ExtensionNameSpaceHandle),
4662 String(StringHandle),
4663 Integer(IntegerHandle),
4664 Float(FloatHandle),
4665 KeyTuple(KeyTupleHandle),
4666 TupleIndex(TupleIndexHandle),
4667 Hole(HoleHandle),
4668}
4669impl KeyView {}
4670#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4671pub struct KeyIdentHandle(pub(crate) super::tree::CstNodeId);
4672impl NonTerminalHandle for KeyIdentHandle {
4673 type View = KeyIdentView;
4674 fn node_id(&self) -> CstNodeId {
4675 self.0
4676 }
4677 fn new_with_visit<F: CstFacade, E>(
4678 index: CstNodeId,
4679 tree: &F,
4680 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4681 ) -> Result<Self, CstConstructError<E>> {
4682 tree.collect_nodes(
4683 index,
4684 [NodeKind::NonTerminal(NonTerminalKind::KeyIdent)],
4685 |[index], visit| Ok((Self(index), visit)),
4686 visit_ignored,
4687 )
4688 }
4689 fn kind(&self) -> NonTerminalKind {
4690 NonTerminalKind::KeyIdent
4691 }
4692 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4693 &self,
4694 tree: &F,
4695 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4696 visit_ignored: &'v mut V,
4697 ) -> Result<O, CstConstructError<E>> {
4698 let mut children = tree.children(self.0);
4699 let Some(child) = children.next() else {
4700 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4701 };
4702 let Some(child_data) = tree.node_data(child) else {
4703 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4704 };
4705 let variant = match child_data.node_kind() {
4706 NodeKind::NonTerminal(NonTerminalKind::Ident) => {
4707 KeyIdentView::Ident(IdentHandle(child))
4708 }
4709 NodeKind::NonTerminal(NonTerminalKind::True) => KeyIdentView::True(TrueHandle(child)),
4710 NodeKind::NonTerminal(NonTerminalKind::False) => {
4711 KeyIdentView::False(FalseHandle(child))
4712 }
4713 NodeKind::NonTerminal(NonTerminalKind::Null) => KeyIdentView::Null(NullHandle(child)),
4714 _ => {
4715 return Err(ViewConstructionError::UnexpectedNode {
4716 node: child,
4717 data: child_data,
4718 expected_kind: child_data.node_kind(),
4719 });
4720 }
4721 };
4722 let (result, _visit) = visit(variant, visit_ignored);
4723 if let Some(extra_child) = children.next() {
4724 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4725 }
4726 Ok(result)
4727 }
4728}
4729#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4730pub enum KeyIdentView {
4731 Ident(IdentHandle),
4732 True(TrueHandle),
4733 False(FalseHandle),
4734 Null(NullHandle),
4735}
4736impl KeyIdentView {}
4737#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4738pub struct KeyTailHandle(pub(crate) super::tree::CstNodeId);
4739impl NonTerminalHandle for KeyTailHandle {
4740 type View = KeyTailView;
4741 fn node_id(&self) -> CstNodeId {
4742 self.0
4743 }
4744 fn new_with_visit<F: CstFacade, E>(
4745 index: CstNodeId,
4746 tree: &F,
4747 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4748 ) -> Result<Self, CstConstructError<E>> {
4749 tree.collect_nodes(
4750 index,
4751 [NodeKind::NonTerminal(NonTerminalKind::KeyTail)],
4752 |[index], visit| Ok((Self(index), visit)),
4753 visit_ignored,
4754 )
4755 }
4756 fn kind(&self) -> NonTerminalKind {
4757 NonTerminalKind::KeyTail
4758 }
4759 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4760 &self,
4761 tree: &F,
4762 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4763 visit_ignored: &'v mut V,
4764 ) -> Result<O, CstConstructError<E>> {
4765 let mut children = tree.children(self.0);
4766 let Some(child) = children.next() else {
4767 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
4768 };
4769 let Some(child_data) = tree.node_data(child) else {
4770 return Err(ViewConstructionError::NodeIdNotFound { node: child });
4771 };
4772 let variant = match child_data.node_kind() {
4773 NodeKind::NonTerminal(NonTerminalKind::DotKey) => {
4774 KeyTailView::DotKey(DotKeyHandle(child))
4775 }
4776 NodeKind::NonTerminal(NonTerminalKind::ArrayMarker) => {
4777 KeyTailView::ArrayMarker(ArrayMarkerHandle(child))
4778 }
4779 _ => {
4780 return Err(ViewConstructionError::UnexpectedNode {
4781 node: child,
4782 data: child_data,
4783 expected_kind: child_data.node_kind(),
4784 });
4785 }
4786 };
4787 let (result, _visit) = visit(variant, visit_ignored);
4788 if let Some(extra_child) = children.next() {
4789 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
4790 }
4791 Ok(result)
4792 }
4793}
4794#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4795pub enum KeyTailView {
4796 DotKey(DotKeyHandle),
4797 ArrayMarker(ArrayMarkerHandle),
4798}
4799impl KeyTailView {}
4800#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4801pub struct KeyTupleHandle(pub(crate) super::tree::CstNodeId);
4802impl NonTerminalHandle for KeyTupleHandle {
4803 type View = KeyTupleView;
4804 fn node_id(&self) -> CstNodeId {
4805 self.0
4806 }
4807 fn new_with_visit<F: CstFacade, E>(
4808 index: CstNodeId,
4809 tree: &F,
4810 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4811 ) -> Result<Self, CstConstructError<E>> {
4812 tree.collect_nodes(
4813 index,
4814 [NodeKind::NonTerminal(NonTerminalKind::KeyTuple)],
4815 |[index], visit| Ok((Self(index), visit)),
4816 visit_ignored,
4817 )
4818 }
4819 fn kind(&self) -> NonTerminalKind {
4820 NonTerminalKind::KeyTuple
4821 }
4822 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4823 &self,
4824 tree: &F,
4825 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4826 visit_ignored: &'v mut V,
4827 ) -> Result<O, CstConstructError<E>> {
4828 tree.collect_nodes(
4829 self.0,
4830 [
4831 NodeKind::NonTerminal(NonTerminalKind::LParen),
4832 NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt),
4833 NodeKind::NonTerminal(NonTerminalKind::RParen),
4834 ],
4835 |[l_paren, key_tuple_opt, r_paren], visit_ignored| {
4836 Ok(visit(
4837 KeyTupleView {
4838 l_paren: LParenHandle(l_paren),
4839 key_tuple_opt: KeyTupleOptHandle(key_tuple_opt),
4840 r_paren: RParenHandle(r_paren),
4841 },
4842 visit_ignored,
4843 ))
4844 },
4845 visit_ignored,
4846 )
4847 }
4848}
4849#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4850pub struct KeyTupleView {
4851 pub l_paren: LParenHandle,
4852 pub key_tuple_opt: KeyTupleOptHandle,
4853 pub r_paren: RParenHandle,
4854}
4855impl KeyTupleView {}
4856#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4857pub struct KeyTupleElementsHandle(pub(crate) super::tree::CstNodeId);
4858impl NonTerminalHandle for KeyTupleElementsHandle {
4859 type View = KeyTupleElementsView;
4860 fn node_id(&self) -> CstNodeId {
4861 self.0
4862 }
4863 fn new_with_visit<F: CstFacade, E>(
4864 index: CstNodeId,
4865 tree: &F,
4866 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4867 ) -> Result<Self, CstConstructError<E>> {
4868 tree.collect_nodes(
4869 index,
4870 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElements)],
4871 |[index], visit| Ok((Self(index), visit)),
4872 visit_ignored,
4873 )
4874 }
4875 fn kind(&self) -> NonTerminalKind {
4876 NonTerminalKind::KeyTupleElements
4877 }
4878 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4879 &self,
4880 tree: &F,
4881 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4882 visit_ignored: &'v mut V,
4883 ) -> Result<O, CstConstructError<E>> {
4884 tree.collect_nodes(
4885 self.0,
4886 [
4887 NodeKind::NonTerminal(NonTerminalKind::KeyValue),
4888 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt),
4889 ],
4890 |[key_value, key_tuple_elements_opt], visit_ignored| {
4891 Ok(visit(
4892 KeyTupleElementsView {
4893 key_value: KeyValueHandle(key_value),
4894 key_tuple_elements_opt: KeyTupleElementsOptHandle(key_tuple_elements_opt),
4895 },
4896 visit_ignored,
4897 ))
4898 },
4899 visit_ignored,
4900 )
4901 }
4902}
4903#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4904pub struct KeyTupleElementsView {
4905 pub key_value: KeyValueHandle,
4906 pub key_tuple_elements_opt: KeyTupleElementsOptHandle,
4907}
4908impl KeyTupleElementsView {}
4909#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4910pub struct KeyTupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
4911impl NonTerminalHandle for KeyTupleElementsOptHandle {
4912 type View = Option<KeyTupleElementsTailHandle>;
4913 fn node_id(&self) -> CstNodeId {
4914 self.0
4915 }
4916 fn new_with_visit<F: CstFacade, E>(
4917 index: CstNodeId,
4918 tree: &F,
4919 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4920 ) -> Result<Self, CstConstructError<E>> {
4921 tree.collect_nodes(
4922 index,
4923 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsOpt)],
4924 |[index], visit| Ok((Self(index), visit)),
4925 visit_ignored,
4926 )
4927 }
4928 fn kind(&self) -> NonTerminalKind {
4929 NonTerminalKind::KeyTupleElementsOpt
4930 }
4931 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4932 &self,
4933 tree: &F,
4934 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4935 visit_ignored: &'v mut V,
4936 ) -> Result<O, CstConstructError<E>> {
4937 if tree.has_no_children(self.0) {
4938 return Ok(visit(None, visit_ignored).0);
4939 }
4940 Ok(visit(
4941 Some(KeyTupleElementsTailHandle::new_with_visit(
4942 self.0,
4943 tree,
4944 visit_ignored,
4945 )?),
4946 visit_ignored,
4947 )
4948 .0)
4949 }
4950}
4951#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
4952pub struct KeyTupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
4953impl NonTerminalHandle for KeyTupleElementsTailHandle {
4954 type View = KeyTupleElementsTailView;
4955 fn node_id(&self) -> CstNodeId {
4956 self.0
4957 }
4958 fn new_with_visit<F: CstFacade, E>(
4959 index: CstNodeId,
4960 tree: &F,
4961 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
4962 ) -> Result<Self, CstConstructError<E>> {
4963 tree.collect_nodes(
4964 index,
4965 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTail)],
4966 |[index], visit| Ok((Self(index), visit)),
4967 visit_ignored,
4968 )
4969 }
4970 fn kind(&self) -> NonTerminalKind {
4971 NonTerminalKind::KeyTupleElementsTail
4972 }
4973 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
4974 &self,
4975 tree: &F,
4976 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
4977 visit_ignored: &'v mut V,
4978 ) -> Result<O, CstConstructError<E>> {
4979 tree.collect_nodes(
4980 self.0,
4981 [
4982 NodeKind::NonTerminal(NonTerminalKind::Comma),
4983 NodeKind::NonTerminal(NonTerminalKind::KeyTupleElementsTailOpt),
4984 ],
4985 |[comma, key_tuple_elements_tail_opt], visit_ignored| {
4986 Ok(visit(
4987 KeyTupleElementsTailView {
4988 comma: CommaHandle(comma),
4989 key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle(
4990 key_tuple_elements_tail_opt,
4991 ),
4992 },
4993 visit_ignored,
4994 ))
4995 },
4996 visit_ignored,
4997 )
4998 }
4999}
5000#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5001pub struct KeyTupleElementsTailView {
5002 pub comma: CommaHandle,
5003 pub key_tuple_elements_tail_opt: KeyTupleElementsTailOptHandle,
5004}
5005impl KeyTupleElementsTailView {}
5006#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5007pub struct KeyTupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
5008impl NonTerminalHandle for KeyTupleElementsTailOptHandle {
5009 type View = Option<KeyTupleElementsHandle>;
5010 fn node_id(&self) -> CstNodeId {
5011 self.0
5012 }
5013 fn new_with_visit<F: CstFacade, E>(
5014 index: CstNodeId,
5015 tree: &F,
5016 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5017 ) -> Result<Self, CstConstructError<E>> {
5018 tree.collect_nodes(
5019 index,
5020 [NodeKind::NonTerminal(
5021 NonTerminalKind::KeyTupleElementsTailOpt,
5022 )],
5023 |[index], visit| Ok((Self(index), visit)),
5024 visit_ignored,
5025 )
5026 }
5027 fn kind(&self) -> NonTerminalKind {
5028 NonTerminalKind::KeyTupleElementsTailOpt
5029 }
5030 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5031 &self,
5032 tree: &F,
5033 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5034 visit_ignored: &'v mut V,
5035 ) -> Result<O, CstConstructError<E>> {
5036 if tree.has_no_children(self.0) {
5037 return Ok(visit(None, visit_ignored).0);
5038 }
5039 Ok(visit(
5040 Some(KeyTupleElementsHandle::new_with_visit(
5041 self.0,
5042 tree,
5043 visit_ignored,
5044 )?),
5045 visit_ignored,
5046 )
5047 .0)
5048 }
5049}
5050#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5051pub struct KeyTupleOptHandle(pub(crate) super::tree::CstNodeId);
5052impl NonTerminalHandle for KeyTupleOptHandle {
5053 type View = Option<KeyTupleElementsHandle>;
5054 fn node_id(&self) -> CstNodeId {
5055 self.0
5056 }
5057 fn new_with_visit<F: CstFacade, E>(
5058 index: CstNodeId,
5059 tree: &F,
5060 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5061 ) -> Result<Self, CstConstructError<E>> {
5062 tree.collect_nodes(
5063 index,
5064 [NodeKind::NonTerminal(NonTerminalKind::KeyTupleOpt)],
5065 |[index], visit| Ok((Self(index), visit)),
5066 visit_ignored,
5067 )
5068 }
5069 fn kind(&self) -> NonTerminalKind {
5070 NonTerminalKind::KeyTupleOpt
5071 }
5072 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5073 &self,
5074 tree: &F,
5075 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5076 visit_ignored: &'v mut V,
5077 ) -> Result<O, CstConstructError<E>> {
5078 if tree.has_no_children(self.0) {
5079 return Ok(visit(None, visit_ignored).0);
5080 }
5081 Ok(visit(
5082 Some(KeyTupleElementsHandle::new_with_visit(
5083 self.0,
5084 tree,
5085 visit_ignored,
5086 )?),
5087 visit_ignored,
5088 )
5089 .0)
5090 }
5091}
5092#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5093pub struct KeyValueHandle(pub(crate) super::tree::CstNodeId);
5094impl NonTerminalHandle for KeyValueHandle {
5095 type View = KeyValueView;
5096 fn node_id(&self) -> CstNodeId {
5097 self.0
5098 }
5099 fn new_with_visit<F: CstFacade, E>(
5100 index: CstNodeId,
5101 tree: &F,
5102 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5103 ) -> Result<Self, CstConstructError<E>> {
5104 tree.collect_nodes(
5105 index,
5106 [NodeKind::NonTerminal(NonTerminalKind::KeyValue)],
5107 |[index], visit| Ok((Self(index), visit)),
5108 visit_ignored,
5109 )
5110 }
5111 fn kind(&self) -> NonTerminalKind {
5112 NonTerminalKind::KeyValue
5113 }
5114 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5115 &self,
5116 tree: &F,
5117 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5118 visit_ignored: &'v mut V,
5119 ) -> Result<O, CstConstructError<E>> {
5120 let mut children = tree.children(self.0);
5121 let Some(child) = children.next() else {
5122 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5123 };
5124 let Some(child_data) = tree.node_data(child) else {
5125 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5126 };
5127 let variant = match child_data.node_kind() {
5128 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
5129 KeyValueView::Integer(IntegerHandle(child))
5130 }
5131 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
5132 KeyValueView::Boolean(BooleanHandle(child))
5133 }
5134 NodeKind::NonTerminal(NonTerminalKind::Str) => KeyValueView::Str(StrHandle(child)),
5135 NodeKind::NonTerminal(NonTerminalKind::KeyTuple) => {
5136 KeyValueView::KeyTuple(KeyTupleHandle(child))
5137 }
5138 NodeKind::NonTerminal(NonTerminalKind::Hole) => KeyValueView::Hole(HoleHandle(child)),
5139 _ => {
5140 return Err(ViewConstructionError::UnexpectedNode {
5141 node: child,
5142 data: child_data,
5143 expected_kind: child_data.node_kind(),
5144 });
5145 }
5146 };
5147 let (result, _visit) = visit(variant, visit_ignored);
5148 if let Some(extra_child) = children.next() {
5149 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5150 }
5151 Ok(result)
5152 }
5153}
5154#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5155pub enum KeyValueView {
5156 Integer(IntegerHandle),
5157 Boolean(BooleanHandle),
5158 Str(StrHandle),
5159 KeyTuple(KeyTupleHandle),
5160 Hole(HoleHandle),
5161}
5162impl KeyValueView {}
5163#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5164pub struct KeysHandle(pub(crate) super::tree::CstNodeId);
5165impl NonTerminalHandle for KeysHandle {
5166 type View = KeysView;
5167 fn node_id(&self) -> CstNodeId {
5168 self.0
5169 }
5170 fn new_with_visit<F: CstFacade, E>(
5171 index: CstNodeId,
5172 tree: &F,
5173 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5174 ) -> Result<Self, CstConstructError<E>> {
5175 tree.collect_nodes(
5176 index,
5177 [NodeKind::NonTerminal(NonTerminalKind::Keys)],
5178 |[index], visit| Ok((Self(index), visit)),
5179 visit_ignored,
5180 )
5181 }
5182 fn kind(&self) -> NonTerminalKind {
5183 NonTerminalKind::Keys
5184 }
5185 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5186 &self,
5187 tree: &F,
5188 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5189 visit_ignored: &'v mut V,
5190 ) -> Result<O, CstConstructError<E>> {
5191 tree.collect_nodes(
5192 self.0,
5193 [
5194 NodeKind::NonTerminal(NonTerminalKind::FirstKey),
5195 NodeKind::NonTerminal(NonTerminalKind::KeysList),
5196 ],
5197 |[first_key, keys_list], visit_ignored| {
5198 Ok(visit(
5199 KeysView {
5200 first_key: FirstKeyHandle(first_key),
5201 keys_list: KeysListHandle(keys_list),
5202 },
5203 visit_ignored,
5204 ))
5205 },
5206 visit_ignored,
5207 )
5208 }
5209}
5210#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5211pub struct KeysView {
5212 pub first_key: FirstKeyHandle,
5213 pub keys_list: KeysListHandle,
5214}
5215impl KeysView {}
5216#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5217pub struct KeysListHandle(pub(crate) super::tree::CstNodeId);
5218impl NonTerminalHandle for KeysListHandle {
5219 type View = Option<KeysListView>;
5220 fn node_id(&self) -> CstNodeId {
5221 self.0
5222 }
5223 fn new_with_visit<F: CstFacade, E>(
5224 index: CstNodeId,
5225 tree: &F,
5226 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5227 ) -> Result<Self, CstConstructError<E>> {
5228 tree.collect_nodes(
5229 index,
5230 [NodeKind::NonTerminal(NonTerminalKind::KeysList)],
5231 |[index], visit| Ok((Self(index), visit)),
5232 visit_ignored,
5233 )
5234 }
5235 fn kind(&self) -> NonTerminalKind {
5236 NonTerminalKind::KeysList
5237 }
5238 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5239 &self,
5240 tree: &F,
5241 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5242 visit_ignored: &'v mut V,
5243 ) -> Result<O, CstConstructError<E>> {
5244 if tree.has_no_children(self.0) {
5245 return Ok(visit(None, visit_ignored).0);
5246 }
5247 tree.collect_nodes(
5248 self.0,
5249 [
5250 NodeKind::NonTerminal(NonTerminalKind::KeyTail),
5251 NodeKind::NonTerminal(NonTerminalKind::KeysList),
5252 ],
5253 |[key_tail, keys_list], visit_ignored| {
5254 Ok(visit(
5255 Some(KeysListView {
5256 key_tail: KeyTailHandle(key_tail),
5257 keys_list: KeysListHandle(keys_list),
5258 }),
5259 visit_ignored,
5260 ))
5261 },
5262 visit_ignored,
5263 )
5264 }
5265}
5266#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5267pub struct KeysListView {
5268 pub key_tail: KeyTailHandle,
5269 pub keys_list: KeysListHandle,
5270}
5271impl<F: CstFacade> RecursiveView<F> for KeysListView {
5272 type Item = KeyTailHandle;
5273 fn get_all_with_visit<E>(
5274 &self,
5275 tree: &F,
5276 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5277 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5278 let mut items = Vec::new();
5279 let mut current_view = Some(*self);
5280 while let Some(item) = current_view {
5281 let Self { key_tail, .. } = item;
5282 items.push(key_tail);
5283 item.keys_list.get_view_with_visit(
5284 tree,
5285 |view, visit_ignored| {
5286 current_view = view;
5287 ((), visit_ignored)
5288 },
5289 visit_ignored,
5290 )?;
5291 }
5292 Ok(items)
5293 }
5294}
5295#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5296pub struct LParenHandle(pub(crate) super::tree::CstNodeId);
5297impl NonTerminalHandle for LParenHandle {
5298 type View = LParenView;
5299 fn node_id(&self) -> CstNodeId {
5300 self.0
5301 }
5302 fn new_with_visit<F: CstFacade, E>(
5303 index: CstNodeId,
5304 tree: &F,
5305 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5306 ) -> Result<Self, CstConstructError<E>> {
5307 tree.collect_nodes(
5308 index,
5309 [NodeKind::NonTerminal(NonTerminalKind::LParen)],
5310 |[index], visit| Ok((Self(index), visit)),
5311 visit_ignored,
5312 )
5313 }
5314 fn kind(&self) -> NonTerminalKind {
5315 NonTerminalKind::LParen
5316 }
5317 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5318 &self,
5319 tree: &F,
5320 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5321 visit_ignored: &'v mut V,
5322 ) -> Result<O, CstConstructError<E>> {
5323 tree.collect_nodes(
5324 self.0,
5325 [NodeKind::Terminal(TerminalKind::LParen)],
5326 |[l_paren], visit_ignored| {
5327 Ok(visit(
5328 LParenView {
5329 l_paren: LParen(l_paren),
5330 },
5331 visit_ignored,
5332 ))
5333 },
5334 visit_ignored,
5335 )
5336 }
5337}
5338#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5339pub struct LParenView {
5340 pub l_paren: LParen,
5341}
5342impl LParenView {}
5343#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5344pub struct LitStrHandle(pub(crate) super::tree::CstNodeId);
5345impl NonTerminalHandle for LitStrHandle {
5346 type View = LitStrView;
5347 fn node_id(&self) -> CstNodeId {
5348 self.0
5349 }
5350 fn new_with_visit<F: CstFacade, E>(
5351 index: CstNodeId,
5352 tree: &F,
5353 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5354 ) -> Result<Self, CstConstructError<E>> {
5355 tree.collect_nodes(
5356 index,
5357 [NodeKind::NonTerminal(NonTerminalKind::LitStr)],
5358 |[index], visit| Ok((Self(index), visit)),
5359 visit_ignored,
5360 )
5361 }
5362 fn kind(&self) -> NonTerminalKind {
5363 NonTerminalKind::LitStr
5364 }
5365 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5366 &self,
5367 tree: &F,
5368 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5369 visit_ignored: &'v mut V,
5370 ) -> Result<O, CstConstructError<E>> {
5371 tree.collect_nodes(
5372 self.0,
5373 [NodeKind::Terminal(TerminalKind::LitStr)],
5374 |[lit_str], visit_ignored| {
5375 Ok(visit(
5376 LitStrView {
5377 lit_str: LitStr(lit_str),
5378 },
5379 visit_ignored,
5380 ))
5381 },
5382 visit_ignored,
5383 )
5384 }
5385}
5386#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5387pub struct LitStrView {
5388 pub lit_str: LitStr,
5389}
5390impl LitStrView {}
5391#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5392pub struct LitStr1Handle(pub(crate) super::tree::CstNodeId);
5393impl NonTerminalHandle for LitStr1Handle {
5394 type View = LitStr1View;
5395 fn node_id(&self) -> CstNodeId {
5396 self.0
5397 }
5398 fn new_with_visit<F: CstFacade, E>(
5399 index: CstNodeId,
5400 tree: &F,
5401 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5402 ) -> Result<Self, CstConstructError<E>> {
5403 tree.collect_nodes(
5404 index,
5405 [NodeKind::NonTerminal(NonTerminalKind::LitStr1)],
5406 |[index], visit| Ok((Self(index), visit)),
5407 visit_ignored,
5408 )
5409 }
5410 fn kind(&self) -> NonTerminalKind {
5411 NonTerminalKind::LitStr1
5412 }
5413 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5414 &self,
5415 tree: &F,
5416 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5417 visit_ignored: &'v mut V,
5418 ) -> Result<O, CstConstructError<E>> {
5419 tree.collect_nodes(
5420 self.0,
5421 [
5422 NodeKind::NonTerminal(NonTerminalKind::LitStr1Start),
5423 NodeKind::NonTerminal(NonTerminalKind::LitStr1List),
5424 NodeKind::NonTerminal(NonTerminalKind::LitStr1End),
5425 ],
5426 |[lit_str_1_start, lit_str_1_list, lit_str_1_end], visit_ignored| {
5427 Ok(visit(
5428 LitStr1View {
5429 lit_str_1_start: LitStr1StartHandle(lit_str_1_start),
5430 lit_str_1_list: LitStr1ListHandle(lit_str_1_list),
5431 lit_str_1_end: LitStr1EndHandle(lit_str_1_end),
5432 },
5433 visit_ignored,
5434 ))
5435 },
5436 visit_ignored,
5437 )
5438 }
5439}
5440#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5441pub struct LitStr1View {
5442 pub lit_str_1_start: LitStr1StartHandle,
5443 pub lit_str_1_list: LitStr1ListHandle,
5444 pub lit_str_1_end: LitStr1EndHandle,
5445}
5446impl LitStr1View {}
5447#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5448pub struct LitStr1EndHandle(pub(crate) super::tree::CstNodeId);
5449impl NonTerminalHandle for LitStr1EndHandle {
5450 type View = LitStr1EndView;
5451 fn node_id(&self) -> CstNodeId {
5452 self.0
5453 }
5454 fn new_with_visit<F: CstFacade, E>(
5455 index: CstNodeId,
5456 tree: &F,
5457 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5458 ) -> Result<Self, CstConstructError<E>> {
5459 tree.collect_nodes(
5460 index,
5461 [NodeKind::NonTerminal(NonTerminalKind::LitStr1End)],
5462 |[index], visit| Ok((Self(index), visit)),
5463 visit_ignored,
5464 )
5465 }
5466 fn kind(&self) -> NonTerminalKind {
5467 NonTerminalKind::LitStr1End
5468 }
5469 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5470 &self,
5471 tree: &F,
5472 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5473 visit_ignored: &'v mut V,
5474 ) -> Result<O, CstConstructError<E>> {
5475 tree.collect_nodes(
5476 self.0,
5477 [NodeKind::Terminal(TerminalKind::LitStr1End)],
5478 |[lit_str_1_end], visit_ignored| {
5479 Ok(visit(
5480 LitStr1EndView {
5481 lit_str_1_end: LitStr1End(lit_str_1_end),
5482 },
5483 visit_ignored,
5484 ))
5485 },
5486 visit_ignored,
5487 )
5488 }
5489}
5490#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5491pub struct LitStr1EndView {
5492 pub lit_str_1_end: LitStr1End,
5493}
5494impl LitStr1EndView {}
5495#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5496pub struct LitStr1ListHandle(pub(crate) super::tree::CstNodeId);
5497impl NonTerminalHandle for LitStr1ListHandle {
5498 type View = Option<LitStr1ListView>;
5499 fn node_id(&self) -> CstNodeId {
5500 self.0
5501 }
5502 fn new_with_visit<F: CstFacade, E>(
5503 index: CstNodeId,
5504 tree: &F,
5505 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5506 ) -> Result<Self, CstConstructError<E>> {
5507 tree.collect_nodes(
5508 index,
5509 [NodeKind::NonTerminal(NonTerminalKind::LitStr1List)],
5510 |[index], visit| Ok((Self(index), visit)),
5511 visit_ignored,
5512 )
5513 }
5514 fn kind(&self) -> NonTerminalKind {
5515 NonTerminalKind::LitStr1List
5516 }
5517 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5518 &self,
5519 tree: &F,
5520 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5521 visit_ignored: &'v mut V,
5522 ) -> Result<O, CstConstructError<E>> {
5523 if tree.has_no_children(self.0) {
5524 return Ok(visit(None, visit_ignored).0);
5525 }
5526 tree.collect_nodes(
5527 self.0,
5528 [
5529 NodeKind::NonTerminal(NonTerminalKind::LitStr1ListGroup),
5530 NodeKind::NonTerminal(NonTerminalKind::LitStr1List),
5531 ],
5532 |[lit_str_1_list_group, lit_str_1_list], visit_ignored| {
5533 Ok(visit(
5534 Some(LitStr1ListView {
5535 lit_str_1_list_group: LitStr1ListGroupHandle(lit_str_1_list_group),
5536 lit_str_1_list: LitStr1ListHandle(lit_str_1_list),
5537 }),
5538 visit_ignored,
5539 ))
5540 },
5541 visit_ignored,
5542 )
5543 }
5544}
5545#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5546pub struct LitStr1ListView {
5547 pub lit_str_1_list_group: LitStr1ListGroupHandle,
5548 pub lit_str_1_list: LitStr1ListHandle,
5549}
5550impl<F: CstFacade> RecursiveView<F> for LitStr1ListView {
5551 type Item = LitStr1ListGroupHandle;
5552 fn get_all_with_visit<E>(
5553 &self,
5554 tree: &F,
5555 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5556 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5557 let mut items = Vec::new();
5558 let mut current_view = Some(*self);
5559 while let Some(item) = current_view {
5560 let Self {
5561 lit_str_1_list_group,
5562 ..
5563 } = item;
5564 items.push(lit_str_1_list_group);
5565 item.lit_str_1_list.get_view_with_visit(
5566 tree,
5567 |view, visit_ignored| {
5568 current_view = view;
5569 ((), visit_ignored)
5570 },
5571 visit_ignored,
5572 )?;
5573 }
5574 Ok(items)
5575 }
5576}
5577#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5578pub struct LitStr1ListGroupHandle(pub(crate) super::tree::CstNodeId);
5579impl NonTerminalHandle for LitStr1ListGroupHandle {
5580 type View = LitStr1ListGroupView;
5581 fn node_id(&self) -> CstNodeId {
5582 self.0
5583 }
5584 fn new_with_visit<F: CstFacade, E>(
5585 index: CstNodeId,
5586 tree: &F,
5587 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5588 ) -> Result<Self, CstConstructError<E>> {
5589 tree.collect_nodes(
5590 index,
5591 [NodeKind::NonTerminal(NonTerminalKind::LitStr1ListGroup)],
5592 |[index], visit| Ok((Self(index), visit)),
5593 visit_ignored,
5594 )
5595 }
5596 fn kind(&self) -> NonTerminalKind {
5597 NonTerminalKind::LitStr1ListGroup
5598 }
5599 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5600 &self,
5601 tree: &F,
5602 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5603 visit_ignored: &'v mut V,
5604 ) -> Result<O, CstConstructError<E>> {
5605 let mut children = tree.children(self.0);
5606 let Some(child) = children.next() else {
5607 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5608 };
5609 let Some(child_data) = tree.node_data(child) else {
5610 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5611 };
5612 let variant = match child_data.node_kind() {
5613 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5614 LitStr1ListGroupView::NoSQuote(NoSQuoteHandle(child))
5615 }
5616 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5617 LitStr1ListGroupView::SQuote(SQuoteHandle(child))
5618 }
5619 _ => {
5620 return Err(ViewConstructionError::UnexpectedNode {
5621 node: child,
5622 data: child_data,
5623 expected_kind: child_data.node_kind(),
5624 });
5625 }
5626 };
5627 let (result, _visit) = visit(variant, visit_ignored);
5628 if let Some(extra_child) = children.next() {
5629 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5630 }
5631 Ok(result)
5632 }
5633}
5634#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5635pub enum LitStr1ListGroupView {
5636 NoSQuote(NoSQuoteHandle),
5637 SQuote(SQuoteHandle),
5638}
5639impl LitStr1ListGroupView {}
5640#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5641pub struct LitStr1StartHandle(pub(crate) super::tree::CstNodeId);
5642impl NonTerminalHandle for LitStr1StartHandle {
5643 type View = LitStr1StartView;
5644 fn node_id(&self) -> CstNodeId {
5645 self.0
5646 }
5647 fn new_with_visit<F: CstFacade, E>(
5648 index: CstNodeId,
5649 tree: &F,
5650 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5651 ) -> Result<Self, CstConstructError<E>> {
5652 tree.collect_nodes(
5653 index,
5654 [NodeKind::NonTerminal(NonTerminalKind::LitStr1Start)],
5655 |[index], visit| Ok((Self(index), visit)),
5656 visit_ignored,
5657 )
5658 }
5659 fn kind(&self) -> NonTerminalKind {
5660 NonTerminalKind::LitStr1Start
5661 }
5662 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5663 &self,
5664 tree: &F,
5665 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5666 visit_ignored: &'v mut V,
5667 ) -> Result<O, CstConstructError<E>> {
5668 tree.collect_nodes(
5669 self.0,
5670 [NodeKind::Terminal(TerminalKind::LitStr1Start)],
5671 |[lit_str_1_start], visit_ignored| {
5672 Ok(visit(
5673 LitStr1StartView {
5674 lit_str_1_start: LitStr1Start(lit_str_1_start),
5675 },
5676 visit_ignored,
5677 ))
5678 },
5679 visit_ignored,
5680 )
5681 }
5682}
5683#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5684pub struct LitStr1StartView {
5685 pub lit_str_1_start: LitStr1Start,
5686}
5687impl LitStr1StartView {}
5688#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5689pub struct LitStr2Handle(pub(crate) super::tree::CstNodeId);
5690impl NonTerminalHandle for LitStr2Handle {
5691 type View = LitStr2View;
5692 fn node_id(&self) -> CstNodeId {
5693 self.0
5694 }
5695 fn new_with_visit<F: CstFacade, E>(
5696 index: CstNodeId,
5697 tree: &F,
5698 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5699 ) -> Result<Self, CstConstructError<E>> {
5700 tree.collect_nodes(
5701 index,
5702 [NodeKind::NonTerminal(NonTerminalKind::LitStr2)],
5703 |[index], visit| Ok((Self(index), visit)),
5704 visit_ignored,
5705 )
5706 }
5707 fn kind(&self) -> NonTerminalKind {
5708 NonTerminalKind::LitStr2
5709 }
5710 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5711 &self,
5712 tree: &F,
5713 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5714 visit_ignored: &'v mut V,
5715 ) -> Result<O, CstConstructError<E>> {
5716 tree.collect_nodes(
5717 self.0,
5718 [
5719 NodeKind::NonTerminal(NonTerminalKind::LitStr2Start),
5720 NodeKind::NonTerminal(NonTerminalKind::LitStr2List),
5721 NodeKind::NonTerminal(NonTerminalKind::LitStr2End),
5722 ],
5723 |[lit_str_2_start, lit_str_2_list, lit_str_2_end], visit_ignored| {
5724 Ok(visit(
5725 LitStr2View {
5726 lit_str_2_start: LitStr2StartHandle(lit_str_2_start),
5727 lit_str_2_list: LitStr2ListHandle(lit_str_2_list),
5728 lit_str_2_end: LitStr2EndHandle(lit_str_2_end),
5729 },
5730 visit_ignored,
5731 ))
5732 },
5733 visit_ignored,
5734 )
5735 }
5736}
5737#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5738pub struct LitStr2View {
5739 pub lit_str_2_start: LitStr2StartHandle,
5740 pub lit_str_2_list: LitStr2ListHandle,
5741 pub lit_str_2_end: LitStr2EndHandle,
5742}
5743impl LitStr2View {}
5744#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5745pub struct LitStr2EndHandle(pub(crate) super::tree::CstNodeId);
5746impl NonTerminalHandle for LitStr2EndHandle {
5747 type View = LitStr2EndView;
5748 fn node_id(&self) -> CstNodeId {
5749 self.0
5750 }
5751 fn new_with_visit<F: CstFacade, E>(
5752 index: CstNodeId,
5753 tree: &F,
5754 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5755 ) -> Result<Self, CstConstructError<E>> {
5756 tree.collect_nodes(
5757 index,
5758 [NodeKind::NonTerminal(NonTerminalKind::LitStr2End)],
5759 |[index], visit| Ok((Self(index), visit)),
5760 visit_ignored,
5761 )
5762 }
5763 fn kind(&self) -> NonTerminalKind {
5764 NonTerminalKind::LitStr2End
5765 }
5766 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5767 &self,
5768 tree: &F,
5769 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5770 visit_ignored: &'v mut V,
5771 ) -> Result<O, CstConstructError<E>> {
5772 tree.collect_nodes(
5773 self.0,
5774 [NodeKind::Terminal(TerminalKind::LitStr2End)],
5775 |[lit_str_2_end], visit_ignored| {
5776 Ok(visit(
5777 LitStr2EndView {
5778 lit_str_2_end: LitStr2End(lit_str_2_end),
5779 },
5780 visit_ignored,
5781 ))
5782 },
5783 visit_ignored,
5784 )
5785 }
5786}
5787#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5788pub struct LitStr2EndView {
5789 pub lit_str_2_end: LitStr2End,
5790}
5791impl LitStr2EndView {}
5792#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5793pub struct LitStr2ListHandle(pub(crate) super::tree::CstNodeId);
5794impl NonTerminalHandle for LitStr2ListHandle {
5795 type View = Option<LitStr2ListView>;
5796 fn node_id(&self) -> CstNodeId {
5797 self.0
5798 }
5799 fn new_with_visit<F: CstFacade, E>(
5800 index: CstNodeId,
5801 tree: &F,
5802 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5803 ) -> Result<Self, CstConstructError<E>> {
5804 tree.collect_nodes(
5805 index,
5806 [NodeKind::NonTerminal(NonTerminalKind::LitStr2List)],
5807 |[index], visit| Ok((Self(index), visit)),
5808 visit_ignored,
5809 )
5810 }
5811 fn kind(&self) -> NonTerminalKind {
5812 NonTerminalKind::LitStr2List
5813 }
5814 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5815 &self,
5816 tree: &F,
5817 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5818 visit_ignored: &'v mut V,
5819 ) -> Result<O, CstConstructError<E>> {
5820 if tree.has_no_children(self.0) {
5821 return Ok(visit(None, visit_ignored).0);
5822 }
5823 tree.collect_nodes(
5824 self.0,
5825 [
5826 NodeKind::NonTerminal(NonTerminalKind::LitStr2ListGroup),
5827 NodeKind::NonTerminal(NonTerminalKind::LitStr2List),
5828 ],
5829 |[lit_str_2_list_group, lit_str_2_list], visit_ignored| {
5830 Ok(visit(
5831 Some(LitStr2ListView {
5832 lit_str_2_list_group: LitStr2ListGroupHandle(lit_str_2_list_group),
5833 lit_str_2_list: LitStr2ListHandle(lit_str_2_list),
5834 }),
5835 visit_ignored,
5836 ))
5837 },
5838 visit_ignored,
5839 )
5840 }
5841}
5842#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5843pub struct LitStr2ListView {
5844 pub lit_str_2_list_group: LitStr2ListGroupHandle,
5845 pub lit_str_2_list: LitStr2ListHandle,
5846}
5847impl<F: CstFacade> RecursiveView<F> for LitStr2ListView {
5848 type Item = LitStr2ListGroupHandle;
5849 fn get_all_with_visit<E>(
5850 &self,
5851 tree: &F,
5852 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5853 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
5854 let mut items = Vec::new();
5855 let mut current_view = Some(*self);
5856 while let Some(item) = current_view {
5857 let Self {
5858 lit_str_2_list_group,
5859 ..
5860 } = item;
5861 items.push(lit_str_2_list_group);
5862 item.lit_str_2_list.get_view_with_visit(
5863 tree,
5864 |view, visit_ignored| {
5865 current_view = view;
5866 ((), visit_ignored)
5867 },
5868 visit_ignored,
5869 )?;
5870 }
5871 Ok(items)
5872 }
5873}
5874#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5875pub struct LitStr2ListGroupHandle(pub(crate) super::tree::CstNodeId);
5876impl NonTerminalHandle for LitStr2ListGroupHandle {
5877 type View = LitStr2ListGroupView;
5878 fn node_id(&self) -> CstNodeId {
5879 self.0
5880 }
5881 fn new_with_visit<F: CstFacade, E>(
5882 index: CstNodeId,
5883 tree: &F,
5884 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5885 ) -> Result<Self, CstConstructError<E>> {
5886 tree.collect_nodes(
5887 index,
5888 [NodeKind::NonTerminal(NonTerminalKind::LitStr2ListGroup)],
5889 |[index], visit| Ok((Self(index), visit)),
5890 visit_ignored,
5891 )
5892 }
5893 fn kind(&self) -> NonTerminalKind {
5894 NonTerminalKind::LitStr2ListGroup
5895 }
5896 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5897 &self,
5898 tree: &F,
5899 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5900 visit_ignored: &'v mut V,
5901 ) -> Result<O, CstConstructError<E>> {
5902 let mut children = tree.children(self.0);
5903 let Some(child) = children.next() else {
5904 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
5905 };
5906 let Some(child_data) = tree.node_data(child) else {
5907 return Err(ViewConstructionError::NodeIdNotFound { node: child });
5908 };
5909 let variant = match child_data.node_kind() {
5910 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
5911 LitStr2ListGroupView::NoSQuote(NoSQuoteHandle(child))
5912 }
5913 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
5914 LitStr2ListGroupView::SQuote(SQuoteHandle(child))
5915 }
5916 _ => {
5917 return Err(ViewConstructionError::UnexpectedNode {
5918 node: child,
5919 data: child_data,
5920 expected_kind: child_data.node_kind(),
5921 });
5922 }
5923 };
5924 let (result, _visit) = visit(variant, visit_ignored);
5925 if let Some(extra_child) = children.next() {
5926 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
5927 }
5928 Ok(result)
5929 }
5930}
5931#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5932pub enum LitStr2ListGroupView {
5933 NoSQuote(NoSQuoteHandle),
5934 SQuote(SQuoteHandle),
5935}
5936impl LitStr2ListGroupView {}
5937#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5938pub struct LitStr2StartHandle(pub(crate) super::tree::CstNodeId);
5939impl NonTerminalHandle for LitStr2StartHandle {
5940 type View = LitStr2StartView;
5941 fn node_id(&self) -> CstNodeId {
5942 self.0
5943 }
5944 fn new_with_visit<F: CstFacade, E>(
5945 index: CstNodeId,
5946 tree: &F,
5947 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5948 ) -> Result<Self, CstConstructError<E>> {
5949 tree.collect_nodes(
5950 index,
5951 [NodeKind::NonTerminal(NonTerminalKind::LitStr2Start)],
5952 |[index], visit| Ok((Self(index), visit)),
5953 visit_ignored,
5954 )
5955 }
5956 fn kind(&self) -> NonTerminalKind {
5957 NonTerminalKind::LitStr2Start
5958 }
5959 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
5960 &self,
5961 tree: &F,
5962 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
5963 visit_ignored: &'v mut V,
5964 ) -> Result<O, CstConstructError<E>> {
5965 tree.collect_nodes(
5966 self.0,
5967 [NodeKind::Terminal(TerminalKind::LitStr2Start)],
5968 |[lit_str_2_start], visit_ignored| {
5969 Ok(visit(
5970 LitStr2StartView {
5971 lit_str_2_start: LitStr2Start(lit_str_2_start),
5972 },
5973 visit_ignored,
5974 ))
5975 },
5976 visit_ignored,
5977 )
5978 }
5979}
5980#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5981pub struct LitStr2StartView {
5982 pub lit_str_2_start: LitStr2Start,
5983}
5984impl LitStr2StartView {}
5985#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
5986pub struct LitStr3Handle(pub(crate) super::tree::CstNodeId);
5987impl NonTerminalHandle for LitStr3Handle {
5988 type View = LitStr3View;
5989 fn node_id(&self) -> CstNodeId {
5990 self.0
5991 }
5992 fn new_with_visit<F: CstFacade, E>(
5993 index: CstNodeId,
5994 tree: &F,
5995 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
5996 ) -> Result<Self, CstConstructError<E>> {
5997 tree.collect_nodes(
5998 index,
5999 [NodeKind::NonTerminal(NonTerminalKind::LitStr3)],
6000 |[index], visit| Ok((Self(index), visit)),
6001 visit_ignored,
6002 )
6003 }
6004 fn kind(&self) -> NonTerminalKind {
6005 NonTerminalKind::LitStr3
6006 }
6007 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6008 &self,
6009 tree: &F,
6010 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6011 visit_ignored: &'v mut V,
6012 ) -> Result<O, CstConstructError<E>> {
6013 tree.collect_nodes(
6014 self.0,
6015 [
6016 NodeKind::NonTerminal(NonTerminalKind::LitStr3Start),
6017 NodeKind::NonTerminal(NonTerminalKind::LitStr3List),
6018 NodeKind::NonTerminal(NonTerminalKind::LitStr3End),
6019 ],
6020 |[lit_str_3_start, lit_str_3_list, lit_str_3_end], visit_ignored| {
6021 Ok(visit(
6022 LitStr3View {
6023 lit_str_3_start: LitStr3StartHandle(lit_str_3_start),
6024 lit_str_3_list: LitStr3ListHandle(lit_str_3_list),
6025 lit_str_3_end: LitStr3EndHandle(lit_str_3_end),
6026 },
6027 visit_ignored,
6028 ))
6029 },
6030 visit_ignored,
6031 )
6032 }
6033}
6034#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6035pub struct LitStr3View {
6036 pub lit_str_3_start: LitStr3StartHandle,
6037 pub lit_str_3_list: LitStr3ListHandle,
6038 pub lit_str_3_end: LitStr3EndHandle,
6039}
6040impl LitStr3View {}
6041#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6042pub struct LitStr3EndHandle(pub(crate) super::tree::CstNodeId);
6043impl NonTerminalHandle for LitStr3EndHandle {
6044 type View = LitStr3EndView;
6045 fn node_id(&self) -> CstNodeId {
6046 self.0
6047 }
6048 fn new_with_visit<F: CstFacade, E>(
6049 index: CstNodeId,
6050 tree: &F,
6051 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6052 ) -> Result<Self, CstConstructError<E>> {
6053 tree.collect_nodes(
6054 index,
6055 [NodeKind::NonTerminal(NonTerminalKind::LitStr3End)],
6056 |[index], visit| Ok((Self(index), visit)),
6057 visit_ignored,
6058 )
6059 }
6060 fn kind(&self) -> NonTerminalKind {
6061 NonTerminalKind::LitStr3End
6062 }
6063 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6064 &self,
6065 tree: &F,
6066 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6067 visit_ignored: &'v mut V,
6068 ) -> Result<O, CstConstructError<E>> {
6069 tree.collect_nodes(
6070 self.0,
6071 [NodeKind::Terminal(TerminalKind::LitStr3End)],
6072 |[lit_str_3_end], visit_ignored| {
6073 Ok(visit(
6074 LitStr3EndView {
6075 lit_str_3_end: LitStr3End(lit_str_3_end),
6076 },
6077 visit_ignored,
6078 ))
6079 },
6080 visit_ignored,
6081 )
6082 }
6083}
6084#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6085pub struct LitStr3EndView {
6086 pub lit_str_3_end: LitStr3End,
6087}
6088impl LitStr3EndView {}
6089#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6090pub struct LitStr3ListHandle(pub(crate) super::tree::CstNodeId);
6091impl NonTerminalHandle for LitStr3ListHandle {
6092 type View = Option<LitStr3ListView>;
6093 fn node_id(&self) -> CstNodeId {
6094 self.0
6095 }
6096 fn new_with_visit<F: CstFacade, E>(
6097 index: CstNodeId,
6098 tree: &F,
6099 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6100 ) -> Result<Self, CstConstructError<E>> {
6101 tree.collect_nodes(
6102 index,
6103 [NodeKind::NonTerminal(NonTerminalKind::LitStr3List)],
6104 |[index], visit| Ok((Self(index), visit)),
6105 visit_ignored,
6106 )
6107 }
6108 fn kind(&self) -> NonTerminalKind {
6109 NonTerminalKind::LitStr3List
6110 }
6111 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6112 &self,
6113 tree: &F,
6114 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6115 visit_ignored: &'v mut V,
6116 ) -> Result<O, CstConstructError<E>> {
6117 if tree.has_no_children(self.0) {
6118 return Ok(visit(None, visit_ignored).0);
6119 }
6120 tree.collect_nodes(
6121 self.0,
6122 [
6123 NodeKind::NonTerminal(NonTerminalKind::LitStr3ListGroup),
6124 NodeKind::NonTerminal(NonTerminalKind::LitStr3List),
6125 ],
6126 |[lit_str_3_list_group, lit_str_3_list], visit_ignored| {
6127 Ok(visit(
6128 Some(LitStr3ListView {
6129 lit_str_3_list_group: LitStr3ListGroupHandle(lit_str_3_list_group),
6130 lit_str_3_list: LitStr3ListHandle(lit_str_3_list),
6131 }),
6132 visit_ignored,
6133 ))
6134 },
6135 visit_ignored,
6136 )
6137 }
6138}
6139#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6140pub struct LitStr3ListView {
6141 pub lit_str_3_list_group: LitStr3ListGroupHandle,
6142 pub lit_str_3_list: LitStr3ListHandle,
6143}
6144impl<F: CstFacade> RecursiveView<F> for LitStr3ListView {
6145 type Item = LitStr3ListGroupHandle;
6146 fn get_all_with_visit<E>(
6147 &self,
6148 tree: &F,
6149 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6150 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
6151 let mut items = Vec::new();
6152 let mut current_view = Some(*self);
6153 while let Some(item) = current_view {
6154 let Self {
6155 lit_str_3_list_group,
6156 ..
6157 } = item;
6158 items.push(lit_str_3_list_group);
6159 item.lit_str_3_list.get_view_with_visit(
6160 tree,
6161 |view, visit_ignored| {
6162 current_view = view;
6163 ((), visit_ignored)
6164 },
6165 visit_ignored,
6166 )?;
6167 }
6168 Ok(items)
6169 }
6170}
6171#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6172pub struct LitStr3ListGroupHandle(pub(crate) super::tree::CstNodeId);
6173impl NonTerminalHandle for LitStr3ListGroupHandle {
6174 type View = LitStr3ListGroupView;
6175 fn node_id(&self) -> CstNodeId {
6176 self.0
6177 }
6178 fn new_with_visit<F: CstFacade, E>(
6179 index: CstNodeId,
6180 tree: &F,
6181 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6182 ) -> Result<Self, CstConstructError<E>> {
6183 tree.collect_nodes(
6184 index,
6185 [NodeKind::NonTerminal(NonTerminalKind::LitStr3ListGroup)],
6186 |[index], visit| Ok((Self(index), visit)),
6187 visit_ignored,
6188 )
6189 }
6190 fn kind(&self) -> NonTerminalKind {
6191 NonTerminalKind::LitStr3ListGroup
6192 }
6193 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6194 &self,
6195 tree: &F,
6196 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6197 visit_ignored: &'v mut V,
6198 ) -> Result<O, CstConstructError<E>> {
6199 let mut children = tree.children(self.0);
6200 let Some(child) = children.next() else {
6201 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6202 };
6203 let Some(child_data) = tree.node_data(child) else {
6204 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6205 };
6206 let variant = match child_data.node_kind() {
6207 NodeKind::NonTerminal(NonTerminalKind::NoSQuote) => {
6208 LitStr3ListGroupView::NoSQuote(NoSQuoteHandle(child))
6209 }
6210 NodeKind::NonTerminal(NonTerminalKind::SQuote) => {
6211 LitStr3ListGroupView::SQuote(SQuoteHandle(child))
6212 }
6213 _ => {
6214 return Err(ViewConstructionError::UnexpectedNode {
6215 node: child,
6216 data: child_data,
6217 expected_kind: child_data.node_kind(),
6218 });
6219 }
6220 };
6221 let (result, _visit) = visit(variant, visit_ignored);
6222 if let Some(extra_child) = children.next() {
6223 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6224 }
6225 Ok(result)
6226 }
6227}
6228#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6229pub enum LitStr3ListGroupView {
6230 NoSQuote(NoSQuoteHandle),
6231 SQuote(SQuoteHandle),
6232}
6233impl LitStr3ListGroupView {}
6234#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6235pub struct LitStr3StartHandle(pub(crate) super::tree::CstNodeId);
6236impl NonTerminalHandle for LitStr3StartHandle {
6237 type View = LitStr3StartView;
6238 fn node_id(&self) -> CstNodeId {
6239 self.0
6240 }
6241 fn new_with_visit<F: CstFacade, E>(
6242 index: CstNodeId,
6243 tree: &F,
6244 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6245 ) -> Result<Self, CstConstructError<E>> {
6246 tree.collect_nodes(
6247 index,
6248 [NodeKind::NonTerminal(NonTerminalKind::LitStr3Start)],
6249 |[index], visit| Ok((Self(index), visit)),
6250 visit_ignored,
6251 )
6252 }
6253 fn kind(&self) -> NonTerminalKind {
6254 NonTerminalKind::LitStr3Start
6255 }
6256 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6257 &self,
6258 tree: &F,
6259 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6260 visit_ignored: &'v mut V,
6261 ) -> Result<O, CstConstructError<E>> {
6262 tree.collect_nodes(
6263 self.0,
6264 [NodeKind::Terminal(TerminalKind::LitStr3Start)],
6265 |[lit_str_3_start], visit_ignored| {
6266 Ok(visit(
6267 LitStr3StartView {
6268 lit_str_3_start: LitStr3Start(lit_str_3_start),
6269 },
6270 visit_ignored,
6271 ))
6272 },
6273 visit_ignored,
6274 )
6275 }
6276}
6277#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6278pub struct LitStr3StartView {
6279 pub lit_str_3_start: LitStr3Start,
6280}
6281impl LitStr3StartView {}
6282#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6283pub struct MapBindHandle(pub(crate) super::tree::CstNodeId);
6284impl NonTerminalHandle for MapBindHandle {
6285 type View = MapBindView;
6286 fn node_id(&self) -> CstNodeId {
6287 self.0
6288 }
6289 fn new_with_visit<F: CstFacade, E>(
6290 index: CstNodeId,
6291 tree: &F,
6292 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6293 ) -> Result<Self, CstConstructError<E>> {
6294 tree.collect_nodes(
6295 index,
6296 [NodeKind::NonTerminal(NonTerminalKind::MapBind)],
6297 |[index], visit| Ok((Self(index), visit)),
6298 visit_ignored,
6299 )
6300 }
6301 fn kind(&self) -> NonTerminalKind {
6302 NonTerminalKind::MapBind
6303 }
6304 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6305 &self,
6306 tree: &F,
6307 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6308 visit_ignored: &'v mut V,
6309 ) -> Result<O, CstConstructError<E>> {
6310 tree.collect_nodes(
6311 self.0,
6312 [NodeKind::Terminal(TerminalKind::MapBind)],
6313 |[map_bind], visit_ignored| {
6314 Ok(visit(
6315 MapBindView {
6316 map_bind: MapBind(map_bind),
6317 },
6318 visit_ignored,
6319 ))
6320 },
6321 visit_ignored,
6322 )
6323 }
6324}
6325#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6326pub struct MapBindView {
6327 pub map_bind: MapBind,
6328}
6329impl MapBindView {}
6330#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6331pub struct NaNHandle(pub(crate) super::tree::CstNodeId);
6332impl NonTerminalHandle for NaNHandle {
6333 type View = NaNView;
6334 fn node_id(&self) -> CstNodeId {
6335 self.0
6336 }
6337 fn new_with_visit<F: CstFacade, E>(
6338 index: CstNodeId,
6339 tree: &F,
6340 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6341 ) -> Result<Self, CstConstructError<E>> {
6342 tree.collect_nodes(
6343 index,
6344 [NodeKind::NonTerminal(NonTerminalKind::NaN)],
6345 |[index], visit| Ok((Self(index), visit)),
6346 visit_ignored,
6347 )
6348 }
6349 fn kind(&self) -> NonTerminalKind {
6350 NonTerminalKind::NaN
6351 }
6352 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6353 &self,
6354 tree: &F,
6355 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6356 visit_ignored: &'v mut V,
6357 ) -> Result<O, CstConstructError<E>> {
6358 tree.collect_nodes(
6359 self.0,
6360 [NodeKind::Terminal(TerminalKind::NaN)],
6361 |[na_n], visit_ignored| Ok(visit(NaNView { na_n: NaN(na_n) }, visit_ignored)),
6362 visit_ignored,
6363 )
6364 }
6365}
6366#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6367pub struct NaNView {
6368 pub na_n: NaN,
6369}
6370impl NaNView {}
6371#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6372pub struct NewlineBindHandle(pub(crate) super::tree::CstNodeId);
6373impl NonTerminalHandle for NewlineBindHandle {
6374 type View = NewlineBindView;
6375 fn node_id(&self) -> CstNodeId {
6376 self.0
6377 }
6378 fn new_with_visit<F: CstFacade, E>(
6379 index: CstNodeId,
6380 tree: &F,
6381 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6382 ) -> Result<Self, CstConstructError<E>> {
6383 tree.collect_nodes(
6384 index,
6385 [NodeKind::NonTerminal(NonTerminalKind::NewlineBind)],
6386 |[index], visit| Ok((Self(index), visit)),
6387 visit_ignored,
6388 )
6389 }
6390 fn kind(&self) -> NonTerminalKind {
6391 NonTerminalKind::NewlineBind
6392 }
6393 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6394 &self,
6395 tree: &F,
6396 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6397 visit_ignored: &'v mut V,
6398 ) -> Result<O, CstConstructError<E>> {
6399 tree.collect_nodes(
6400 self.0,
6401 [NodeKind::Terminal(TerminalKind::NewlineBind)],
6402 |[newline_bind], visit_ignored| {
6403 Ok(visit(
6404 NewlineBindView {
6405 newline_bind: NewlineBind(newline_bind),
6406 },
6407 visit_ignored,
6408 ))
6409 },
6410 visit_ignored,
6411 )
6412 }
6413}
6414#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6415pub struct NewlineBindView {
6416 pub newline_bind: NewlineBind,
6417}
6418impl NewlineBindView {}
6419#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6420pub struct NewlineHeadHandle(pub(crate) super::tree::CstNodeId);
6421impl NonTerminalHandle for NewlineHeadHandle {
6422 type View = NewlineHeadView;
6423 fn node_id(&self) -> CstNodeId {
6424 self.0
6425 }
6426 fn new_with_visit<F: CstFacade, E>(
6427 index: CstNodeId,
6428 tree: &F,
6429 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6430 ) -> Result<Self, CstConstructError<E>> {
6431 tree.collect_nodes(
6432 index,
6433 [NodeKind::NonTerminal(NonTerminalKind::NewlineHead)],
6434 |[index], visit| Ok((Self(index), visit)),
6435 visit_ignored,
6436 )
6437 }
6438 fn kind(&self) -> NonTerminalKind {
6439 NonTerminalKind::NewlineHead
6440 }
6441 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6442 &self,
6443 tree: &F,
6444 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6445 visit_ignored: &'v mut V,
6446 ) -> Result<O, CstConstructError<E>> {
6447 tree.collect_nodes(
6448 self.0,
6449 [
6450 NodeKind::NonTerminal(NonTerminalKind::GrammarNewline),
6451 NodeKind::NonTerminal(NonTerminalKind::NewlineHeadOpt),
6452 ],
6453 |[grammar_newline, newline_head_opt], visit_ignored| {
6454 Ok(visit(
6455 NewlineHeadView {
6456 grammar_newline: GrammarNewlineHandle(grammar_newline),
6457 newline_head_opt: NewlineHeadOptHandle(newline_head_opt),
6458 },
6459 visit_ignored,
6460 ))
6461 },
6462 visit_ignored,
6463 )
6464 }
6465}
6466#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6467pub struct NewlineHeadView {
6468 pub grammar_newline: GrammarNewlineHandle,
6469 pub newline_head_opt: NewlineHeadOptHandle,
6470}
6471impl NewlineHeadView {}
6472#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6473pub struct NewlineHeadOptHandle(pub(crate) super::tree::CstNodeId);
6474impl NonTerminalHandle for NewlineHeadOptHandle {
6475 type View = Option<FlatRootBindingHandle>;
6476 fn node_id(&self) -> CstNodeId {
6477 self.0
6478 }
6479 fn new_with_visit<F: CstFacade, E>(
6480 index: CstNodeId,
6481 tree: &F,
6482 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6483 ) -> Result<Self, CstConstructError<E>> {
6484 tree.collect_nodes(
6485 index,
6486 [NodeKind::NonTerminal(NonTerminalKind::NewlineHeadOpt)],
6487 |[index], visit| Ok((Self(index), visit)),
6488 visit_ignored,
6489 )
6490 }
6491 fn kind(&self) -> NonTerminalKind {
6492 NonTerminalKind::NewlineHeadOpt
6493 }
6494 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6495 &self,
6496 tree: &F,
6497 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6498 visit_ignored: &'v mut V,
6499 ) -> Result<O, CstConstructError<E>> {
6500 if tree.has_no_children(self.0) {
6501 return Ok(visit(None, visit_ignored).0);
6502 }
6503 Ok(visit(
6504 Some(FlatRootBindingHandle::new_with_visit(
6505 self.0,
6506 tree,
6507 visit_ignored,
6508 )?),
6509 visit_ignored,
6510 )
6511 .0)
6512 }
6513}
6514#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6515pub struct NewlineTextStartHandle(pub(crate) super::tree::CstNodeId);
6516impl NonTerminalHandle for NewlineTextStartHandle {
6517 type View = NewlineTextStartView;
6518 fn node_id(&self) -> CstNodeId {
6519 self.0
6520 }
6521 fn new_with_visit<F: CstFacade, E>(
6522 index: CstNodeId,
6523 tree: &F,
6524 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6525 ) -> Result<Self, CstConstructError<E>> {
6526 tree.collect_nodes(
6527 index,
6528 [NodeKind::NonTerminal(NonTerminalKind::NewlineTextStart)],
6529 |[index], visit| Ok((Self(index), visit)),
6530 visit_ignored,
6531 )
6532 }
6533 fn kind(&self) -> NonTerminalKind {
6534 NonTerminalKind::NewlineTextStart
6535 }
6536 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6537 &self,
6538 tree: &F,
6539 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6540 visit_ignored: &'v mut V,
6541 ) -> Result<O, CstConstructError<E>> {
6542 tree.collect_nodes(
6543 self.0,
6544 [NodeKind::Terminal(TerminalKind::NewlineTextStart)],
6545 |[newline_text_start], visit_ignored| {
6546 Ok(visit(
6547 NewlineTextStartView {
6548 newline_text_start: NewlineTextStart(newline_text_start),
6549 },
6550 visit_ignored,
6551 ))
6552 },
6553 visit_ignored,
6554 )
6555 }
6556}
6557#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6558pub struct NewlineTextStartView {
6559 pub newline_text_start: NewlineTextStart,
6560}
6561impl NewlineTextStartView {}
6562#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6563pub struct NoBacktickHandle(pub(crate) super::tree::CstNodeId);
6564impl NonTerminalHandle for NoBacktickHandle {
6565 type View = NoBacktickView;
6566 fn node_id(&self) -> CstNodeId {
6567 self.0
6568 }
6569 fn new_with_visit<F: CstFacade, E>(
6570 index: CstNodeId,
6571 tree: &F,
6572 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6573 ) -> Result<Self, CstConstructError<E>> {
6574 tree.collect_nodes(
6575 index,
6576 [NodeKind::NonTerminal(NonTerminalKind::NoBacktick)],
6577 |[index], visit| Ok((Self(index), visit)),
6578 visit_ignored,
6579 )
6580 }
6581 fn kind(&self) -> NonTerminalKind {
6582 NonTerminalKind::NoBacktick
6583 }
6584 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6585 &self,
6586 tree: &F,
6587 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6588 visit_ignored: &'v mut V,
6589 ) -> Result<O, CstConstructError<E>> {
6590 tree.collect_nodes(
6591 self.0,
6592 [NodeKind::Terminal(TerminalKind::NoBacktick)],
6593 |[no_backtick], visit_ignored| {
6594 Ok(visit(
6595 NoBacktickView {
6596 no_backtick: NoBacktick(no_backtick),
6597 },
6598 visit_ignored,
6599 ))
6600 },
6601 visit_ignored,
6602 )
6603 }
6604}
6605#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6606pub struct NoBacktickView {
6607 pub no_backtick: NoBacktick,
6608}
6609impl NoBacktickView {}
6610#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6611pub struct NoSQuoteHandle(pub(crate) super::tree::CstNodeId);
6612impl NonTerminalHandle for NoSQuoteHandle {
6613 type View = NoSQuoteView;
6614 fn node_id(&self) -> CstNodeId {
6615 self.0
6616 }
6617 fn new_with_visit<F: CstFacade, E>(
6618 index: CstNodeId,
6619 tree: &F,
6620 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6621 ) -> Result<Self, CstConstructError<E>> {
6622 tree.collect_nodes(
6623 index,
6624 [NodeKind::NonTerminal(NonTerminalKind::NoSQuote)],
6625 |[index], visit| Ok((Self(index), visit)),
6626 visit_ignored,
6627 )
6628 }
6629 fn kind(&self) -> NonTerminalKind {
6630 NonTerminalKind::NoSQuote
6631 }
6632 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6633 &self,
6634 tree: &F,
6635 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6636 visit_ignored: &'v mut V,
6637 ) -> Result<O, CstConstructError<E>> {
6638 tree.collect_nodes(
6639 self.0,
6640 [NodeKind::Terminal(TerminalKind::NoSQuote)],
6641 |[no_s_quote], visit_ignored| {
6642 Ok(visit(
6643 NoSQuoteView {
6644 no_s_quote: NoSQuote(no_s_quote),
6645 },
6646 visit_ignored,
6647 ))
6648 },
6649 visit_ignored,
6650 )
6651 }
6652}
6653#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6654pub struct NoSQuoteView {
6655 pub no_s_quote: NoSQuote,
6656}
6657impl NoSQuoteView {}
6658#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6659pub struct NullHandle(pub(crate) super::tree::CstNodeId);
6660impl NonTerminalHandle for NullHandle {
6661 type View = NullView;
6662 fn node_id(&self) -> CstNodeId {
6663 self.0
6664 }
6665 fn new_with_visit<F: CstFacade, E>(
6666 index: CstNodeId,
6667 tree: &F,
6668 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6669 ) -> Result<Self, CstConstructError<E>> {
6670 tree.collect_nodes(
6671 index,
6672 [NodeKind::NonTerminal(NonTerminalKind::Null)],
6673 |[index], visit| Ok((Self(index), visit)),
6674 visit_ignored,
6675 )
6676 }
6677 fn kind(&self) -> NonTerminalKind {
6678 NonTerminalKind::Null
6679 }
6680 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6681 &self,
6682 tree: &F,
6683 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6684 visit_ignored: &'v mut V,
6685 ) -> Result<O, CstConstructError<E>> {
6686 tree.collect_nodes(
6687 self.0,
6688 [NodeKind::Terminal(TerminalKind::Null)],
6689 |[null], visit_ignored| Ok(visit(NullView { null: Null(null) }, visit_ignored)),
6690 visit_ignored,
6691 )
6692 }
6693}
6694#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6695pub struct NullView {
6696 pub null: Null,
6697}
6698impl NullView {}
6699#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6700pub struct NumberHandle(pub(crate) super::tree::CstNodeId);
6701impl NonTerminalHandle for NumberHandle {
6702 type View = NumberView;
6703 fn node_id(&self) -> CstNodeId {
6704 self.0
6705 }
6706 fn new_with_visit<F: CstFacade, E>(
6707 index: CstNodeId,
6708 tree: &F,
6709 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6710 ) -> Result<Self, CstConstructError<E>> {
6711 tree.collect_nodes(
6712 index,
6713 [NodeKind::NonTerminal(NonTerminalKind::Number)],
6714 |[index], visit| Ok((Self(index), visit)),
6715 visit_ignored,
6716 )
6717 }
6718 fn kind(&self) -> NonTerminalKind {
6719 NonTerminalKind::Number
6720 }
6721 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6722 &self,
6723 tree: &F,
6724 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6725 visit_ignored: &'v mut V,
6726 ) -> Result<O, CstConstructError<E>> {
6727 let mut children = tree.children(self.0);
6728 let Some(child) = children.next() else {
6729 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
6730 };
6731 let Some(child_data) = tree.node_data(child) else {
6732 return Err(ViewConstructionError::NodeIdNotFound { node: child });
6733 };
6734 let variant = match child_data.node_kind() {
6735 NodeKind::NonTerminal(NonTerminalKind::Float) => NumberView::Float(FloatHandle(child)),
6736 NodeKind::NonTerminal(NonTerminalKind::Integer) => {
6737 NumberView::Integer(IntegerHandle(child))
6738 }
6739 NodeKind::NonTerminal(NonTerminalKind::Inf) => NumberView::Inf(InfHandle(child)),
6740 NodeKind::NonTerminal(NonTerminalKind::NaN) => NumberView::NaN(NaNHandle(child)),
6741 _ => {
6742 return Err(ViewConstructionError::UnexpectedNode {
6743 node: child,
6744 data: child_data,
6745 expected_kind: child_data.node_kind(),
6746 });
6747 }
6748 };
6749 let (result, _visit) = visit(variant, visit_ignored);
6750 if let Some(extra_child) = children.next() {
6751 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
6752 }
6753 Ok(result)
6754 }
6755}
6756#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6757pub enum NumberView {
6758 Float(FloatHandle),
6759 Integer(IntegerHandle),
6760 Inf(InfHandle),
6761 NaN(NaNHandle),
6762}
6763impl NumberView {}
6764#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6765pub struct ObjectHandle(pub(crate) super::tree::CstNodeId);
6766impl NonTerminalHandle for ObjectHandle {
6767 type View = ObjectView;
6768 fn node_id(&self) -> CstNodeId {
6769 self.0
6770 }
6771 fn new_with_visit<F: CstFacade, E>(
6772 index: CstNodeId,
6773 tree: &F,
6774 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6775 ) -> Result<Self, CstConstructError<E>> {
6776 tree.collect_nodes(
6777 index,
6778 [NodeKind::NonTerminal(NonTerminalKind::Object)],
6779 |[index], visit| Ok((Self(index), visit)),
6780 visit_ignored,
6781 )
6782 }
6783 fn kind(&self) -> NonTerminalKind {
6784 NonTerminalKind::Object
6785 }
6786 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6787 &self,
6788 tree: &F,
6789 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6790 visit_ignored: &'v mut V,
6791 ) -> Result<O, CstConstructError<E>> {
6792 tree.collect_nodes(
6793 self.0,
6794 [
6795 NodeKind::NonTerminal(NonTerminalKind::Begin),
6796 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt),
6797 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
6798 NodeKind::NonTerminal(NonTerminalKind::End),
6799 ],
6800 |[begin, object_opt, object_list, end], visit_ignored| {
6801 Ok(visit(
6802 ObjectView {
6803 begin: BeginHandle(begin),
6804 object_opt: ObjectOptHandle(object_opt),
6805 object_list: ObjectListHandle(object_list),
6806 end: EndHandle(end),
6807 },
6808 visit_ignored,
6809 ))
6810 },
6811 visit_ignored,
6812 )
6813 }
6814}
6815#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6816pub struct ObjectView {
6817 pub begin: BeginHandle,
6818 pub object_opt: ObjectOptHandle,
6819 pub object_list: ObjectListHandle,
6820 pub end: EndHandle,
6821}
6822impl ObjectView {}
6823#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6824pub struct ObjectListHandle(pub(crate) super::tree::CstNodeId);
6825impl NonTerminalHandle for ObjectListHandle {
6826 type View = Option<ObjectListView>;
6827 fn node_id(&self) -> CstNodeId {
6828 self.0
6829 }
6830 fn new_with_visit<F: CstFacade, E>(
6831 index: CstNodeId,
6832 tree: &F,
6833 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6834 ) -> Result<Self, CstConstructError<E>> {
6835 tree.collect_nodes(
6836 index,
6837 [NodeKind::NonTerminal(NonTerminalKind::ObjectList)],
6838 |[index], visit| Ok((Self(index), visit)),
6839 visit_ignored,
6840 )
6841 }
6842 fn kind(&self) -> NonTerminalKind {
6843 NonTerminalKind::ObjectList
6844 }
6845 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6846 &self,
6847 tree: &F,
6848 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6849 visit_ignored: &'v mut V,
6850 ) -> Result<O, CstConstructError<E>> {
6851 if tree.has_no_children(self.0) {
6852 return Ok(visit(None, visit_ignored).0);
6853 }
6854 tree.collect_nodes(
6855 self.0,
6856 [
6857 NodeKind::NonTerminal(NonTerminalKind::Keys),
6858 NodeKind::NonTerminal(NonTerminalKind::MapBind),
6859 NodeKind::NonTerminal(NonTerminalKind::Value),
6860 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0),
6861 NodeKind::NonTerminal(NonTerminalKind::ObjectList),
6862 ],
6863 |[keys, map_bind, value, object_opt_0, object_list], visit_ignored| {
6864 Ok(visit(
6865 Some(ObjectListView {
6866 keys: KeysHandle(keys),
6867 map_bind: MapBindHandle(map_bind),
6868 value: ValueHandle(value),
6869 object_opt_0: ObjectOpt0Handle(object_opt_0),
6870 object_list: ObjectListHandle(object_list),
6871 }),
6872 visit_ignored,
6873 ))
6874 },
6875 visit_ignored,
6876 )
6877 }
6878}
6879#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6880pub struct ObjectListView {
6881 pub keys: KeysHandle,
6882 pub map_bind: MapBindHandle,
6883 pub value: ValueHandle,
6884 pub object_opt_0: ObjectOpt0Handle,
6885 pub object_list: ObjectListHandle,
6886}
6887impl<F: CstFacade> RecursiveView<F> for ObjectListView {
6888 type Item = ObjectListItem;
6889 fn get_all_with_visit<E>(
6890 &self,
6891 tree: &F,
6892 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6893 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
6894 let mut items = Vec::new();
6895 let mut current_view = Some(*self);
6896 while let Some(item) = current_view {
6897 let Self {
6898 keys,
6899 map_bind,
6900 value,
6901 object_opt_0,
6902 ..
6903 } = item;
6904 items.push(ObjectListItem {
6905 keys,
6906 map_bind,
6907 value,
6908 object_opt_0,
6909 });
6910 item.object_list.get_view_with_visit(
6911 tree,
6912 |view, visit_ignored| {
6913 current_view = view;
6914 ((), visit_ignored)
6915 },
6916 visit_ignored,
6917 )?;
6918 }
6919 Ok(items)
6920 }
6921}
6922#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6923pub struct ObjectListItem {
6924 pub keys: KeysHandle,
6925 pub map_bind: MapBindHandle,
6926 pub value: ValueHandle,
6927 pub object_opt_0: ObjectOpt0Handle,
6928}
6929#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6930pub struct ObjectOptHandle(pub(crate) super::tree::CstNodeId);
6931impl NonTerminalHandle for ObjectOptHandle {
6932 type View = Option<ObjectOptView>;
6933 fn node_id(&self) -> CstNodeId {
6934 self.0
6935 }
6936 fn new_with_visit<F: CstFacade, E>(
6937 index: CstNodeId,
6938 tree: &F,
6939 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6940 ) -> Result<Self, CstConstructError<E>> {
6941 tree.collect_nodes(
6942 index,
6943 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt)],
6944 |[index], visit| Ok((Self(index), visit)),
6945 visit_ignored,
6946 )
6947 }
6948 fn kind(&self) -> NonTerminalKind {
6949 NonTerminalKind::ObjectOpt
6950 }
6951 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
6952 &self,
6953 tree: &F,
6954 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
6955 visit_ignored: &'v mut V,
6956 ) -> Result<O, CstConstructError<E>> {
6957 if tree.has_no_children(self.0) {
6958 return Ok(visit(None, visit_ignored).0);
6959 }
6960 tree.collect_nodes(
6961 self.0,
6962 [
6963 NodeKind::NonTerminal(NonTerminalKind::ValueBinding),
6964 NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1),
6965 ],
6966 |[value_binding, object_opt_1], visit_ignored| {
6967 Ok(visit(
6968 Some(ObjectOptView {
6969 value_binding: ValueBindingHandle(value_binding),
6970 object_opt_1: ObjectOpt1Handle(object_opt_1),
6971 }),
6972 visit_ignored,
6973 ))
6974 },
6975 visit_ignored,
6976 )
6977 }
6978}
6979#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6980pub struct ObjectOptView {
6981 pub value_binding: ValueBindingHandle,
6982 pub object_opt_1: ObjectOpt1Handle,
6983}
6984#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
6985pub struct ObjectOpt0Handle(pub(crate) super::tree::CstNodeId);
6986impl NonTerminalHandle for ObjectOpt0Handle {
6987 type View = Option<CommaHandle>;
6988 fn node_id(&self) -> CstNodeId {
6989 self.0
6990 }
6991 fn new_with_visit<F: CstFacade, E>(
6992 index: CstNodeId,
6993 tree: &F,
6994 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
6995 ) -> Result<Self, CstConstructError<E>> {
6996 tree.collect_nodes(
6997 index,
6998 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt0)],
6999 |[index], visit| Ok((Self(index), visit)),
7000 visit_ignored,
7001 )
7002 }
7003 fn kind(&self) -> NonTerminalKind {
7004 NonTerminalKind::ObjectOpt0
7005 }
7006 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7007 &self,
7008 tree: &F,
7009 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7010 visit_ignored: &'v mut V,
7011 ) -> Result<O, CstConstructError<E>> {
7012 if tree.has_no_children(self.0) {
7013 return Ok(visit(None, visit_ignored).0);
7014 }
7015 Ok(visit(
7016 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
7017 visit_ignored,
7018 )
7019 .0)
7020 }
7021}
7022#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7023pub struct ObjectOpt1Handle(pub(crate) super::tree::CstNodeId);
7024impl NonTerminalHandle for ObjectOpt1Handle {
7025 type View = Option<CommaHandle>;
7026 fn node_id(&self) -> CstNodeId {
7027 self.0
7028 }
7029 fn new_with_visit<F: CstFacade, E>(
7030 index: CstNodeId,
7031 tree: &F,
7032 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7033 ) -> Result<Self, CstConstructError<E>> {
7034 tree.collect_nodes(
7035 index,
7036 [NodeKind::NonTerminal(NonTerminalKind::ObjectOpt1)],
7037 |[index], visit| Ok((Self(index), visit)),
7038 visit_ignored,
7039 )
7040 }
7041 fn kind(&self) -> NonTerminalKind {
7042 NonTerminalKind::ObjectOpt1
7043 }
7044 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7045 &self,
7046 tree: &F,
7047 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7048 visit_ignored: &'v mut V,
7049 ) -> Result<O, CstConstructError<E>> {
7050 if tree.has_no_children(self.0) {
7051 return Ok(visit(None, visit_ignored).0);
7052 }
7053 Ok(visit(
7054 Some(CommaHandle::new_with_visit(self.0, tree, visit_ignored)?),
7055 visit_ignored,
7056 )
7057 .0)
7058 }
7059}
7060#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7061pub struct RParenHandle(pub(crate) super::tree::CstNodeId);
7062impl NonTerminalHandle for RParenHandle {
7063 type View = RParenView;
7064 fn node_id(&self) -> CstNodeId {
7065 self.0
7066 }
7067 fn new_with_visit<F: CstFacade, E>(
7068 index: CstNodeId,
7069 tree: &F,
7070 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7071 ) -> Result<Self, CstConstructError<E>> {
7072 tree.collect_nodes(
7073 index,
7074 [NodeKind::NonTerminal(NonTerminalKind::RParen)],
7075 |[index], visit| Ok((Self(index), visit)),
7076 visit_ignored,
7077 )
7078 }
7079 fn kind(&self) -> NonTerminalKind {
7080 NonTerminalKind::RParen
7081 }
7082 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7083 &self,
7084 tree: &F,
7085 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7086 visit_ignored: &'v mut V,
7087 ) -> Result<O, CstConstructError<E>> {
7088 tree.collect_nodes(
7089 self.0,
7090 [NodeKind::Terminal(TerminalKind::RParen)],
7091 |[r_paren], visit_ignored| {
7092 Ok(visit(
7093 RParenView {
7094 r_paren: RParen(r_paren),
7095 },
7096 visit_ignored,
7097 ))
7098 },
7099 visit_ignored,
7100 )
7101 }
7102}
7103#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7104pub struct RParenView {
7105 pub r_paren: RParen,
7106}
7107impl RParenView {}
7108#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7109pub struct RootBindingHandle(pub(crate) super::tree::CstNodeId);
7110impl NonTerminalHandle for RootBindingHandle {
7111 type View = RootBindingView;
7112 fn node_id(&self) -> CstNodeId {
7113 self.0
7114 }
7115 fn new_with_visit<F: CstFacade, E>(
7116 index: CstNodeId,
7117 tree: &F,
7118 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7119 ) -> Result<Self, CstConstructError<E>> {
7120 tree.collect_nodes(
7121 index,
7122 [NodeKind::NonTerminal(NonTerminalKind::RootBinding)],
7123 |[index], visit| Ok((Self(index), visit)),
7124 visit_ignored,
7125 )
7126 }
7127 fn kind(&self) -> NonTerminalKind {
7128 NonTerminalKind::RootBinding
7129 }
7130 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7131 &self,
7132 tree: &F,
7133 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7134 visit_ignored: &'v mut V,
7135 ) -> Result<O, CstConstructError<E>> {
7136 let mut children = tree.children(self.0);
7137 let Some(child) = children.next() else {
7138 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7139 };
7140 let Some(child_data) = tree.node_data(child) else {
7141 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7142 };
7143 let variant = match child_data.node_kind() {
7144 NodeKind::NonTerminal(NonTerminalKind::RootValueBinding) => {
7145 RootBindingView::RootValueBinding(RootValueBindingHandle(child))
7146 }
7147 NodeKind::NonTerminal(NonTerminalKind::RootTextBinding) => {
7148 RootBindingView::RootTextBinding(RootTextBindingHandle(child))
7149 }
7150 _ => {
7151 return Err(ViewConstructionError::UnexpectedNode {
7152 node: child,
7153 data: child_data,
7154 expected_kind: child_data.node_kind(),
7155 });
7156 }
7157 };
7158 let (result, _visit) = visit(variant, visit_ignored);
7159 if let Some(extra_child) = children.next() {
7160 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7161 }
7162 Ok(result)
7163 }
7164}
7165#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7166pub enum RootBindingView {
7167 RootValueBinding(RootValueBindingHandle),
7168 RootTextBinding(RootTextBindingHandle),
7169}
7170impl RootBindingView {}
7171#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7172pub struct RootTextBindingHandle(pub(crate) super::tree::CstNodeId);
7173impl NonTerminalHandle for RootTextBindingHandle {
7174 type View = RootTextBindingView;
7175 fn node_id(&self) -> CstNodeId {
7176 self.0
7177 }
7178 fn new_with_visit<F: CstFacade, E>(
7179 index: CstNodeId,
7180 tree: &F,
7181 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7182 ) -> Result<Self, CstConstructError<E>> {
7183 tree.collect_nodes(
7184 index,
7185 [NodeKind::NonTerminal(NonTerminalKind::RootTextBinding)],
7186 |[index], visit| Ok((Self(index), visit)),
7187 visit_ignored,
7188 )
7189 }
7190 fn kind(&self) -> NonTerminalKind {
7191 NonTerminalKind::RootTextBinding
7192 }
7193 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7194 &self,
7195 tree: &F,
7196 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7197 visit_ignored: &'v mut V,
7198 ) -> Result<O, CstConstructError<E>> {
7199 tree.collect_nodes(
7200 self.0,
7201 [
7202 NodeKind::NonTerminal(NonTerminalKind::NewlineTextStart),
7203 NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt),
7204 NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt0),
7205 NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt1),
7206 ],
7207 |[
7208 newline_text_start,
7209 root_text_binding_opt,
7210 root_text_binding_opt_0,
7211 root_text_binding_opt_1,
7212 ],
7213 visit_ignored| {
7214 Ok(visit(
7215 RootTextBindingView {
7216 newline_text_start: NewlineTextStartHandle(newline_text_start),
7217 root_text_binding_opt: RootTextBindingOptHandle(root_text_binding_opt),
7218 root_text_binding_opt_0: RootTextBindingOpt0Handle(root_text_binding_opt_0),
7219 root_text_binding_opt_1: RootTextBindingOpt1Handle(root_text_binding_opt_1),
7220 },
7221 visit_ignored,
7222 ))
7223 },
7224 visit_ignored,
7225 )
7226 }
7227}
7228#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7229pub struct RootTextBindingView {
7230 pub newline_text_start: NewlineTextStartHandle,
7231 pub root_text_binding_opt: RootTextBindingOptHandle,
7232 pub root_text_binding_opt_0: RootTextBindingOpt0Handle,
7233 pub root_text_binding_opt_1: RootTextBindingOpt1Handle,
7234}
7235impl RootTextBindingView {}
7236#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7237pub struct RootTextBindingOptHandle(pub(crate) super::tree::CstNodeId);
7238impl NonTerminalHandle for RootTextBindingOptHandle {
7239 type View = Option<WsHandle>;
7240 fn node_id(&self) -> CstNodeId {
7241 self.0
7242 }
7243 fn new_with_visit<F: CstFacade, E>(
7244 index: CstNodeId,
7245 tree: &F,
7246 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7247 ) -> Result<Self, CstConstructError<E>> {
7248 tree.collect_nodes(
7249 index,
7250 [NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt)],
7251 |[index], visit| Ok((Self(index), visit)),
7252 visit_ignored,
7253 )
7254 }
7255 fn kind(&self) -> NonTerminalKind {
7256 NonTerminalKind::RootTextBindingOpt
7257 }
7258 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7259 &self,
7260 tree: &F,
7261 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7262 visit_ignored: &'v mut V,
7263 ) -> Result<O, CstConstructError<E>> {
7264 if tree.has_no_children(self.0) {
7265 return Ok(visit(None, visit_ignored).0);
7266 }
7267 Ok(visit(
7268 Some(WsHandle::new_with_visit(self.0, tree, visit_ignored)?),
7269 visit_ignored,
7270 )
7271 .0)
7272 }
7273}
7274#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7275pub struct RootTextBindingOpt0Handle(pub(crate) super::tree::CstNodeId);
7276impl NonTerminalHandle for RootTextBindingOpt0Handle {
7277 type View = Option<TextHandle>;
7278 fn node_id(&self) -> CstNodeId {
7279 self.0
7280 }
7281 fn new_with_visit<F: CstFacade, E>(
7282 index: CstNodeId,
7283 tree: &F,
7284 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7285 ) -> Result<Self, CstConstructError<E>> {
7286 tree.collect_nodes(
7287 index,
7288 [NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt0)],
7289 |[index], visit| Ok((Self(index), visit)),
7290 visit_ignored,
7291 )
7292 }
7293 fn kind(&self) -> NonTerminalKind {
7294 NonTerminalKind::RootTextBindingOpt0
7295 }
7296 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7297 &self,
7298 tree: &F,
7299 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7300 visit_ignored: &'v mut V,
7301 ) -> Result<O, CstConstructError<E>> {
7302 if tree.has_no_children(self.0) {
7303 return Ok(visit(None, visit_ignored).0);
7304 }
7305 Ok(visit(
7306 Some(TextHandle::new_with_visit(self.0, tree, visit_ignored)?),
7307 visit_ignored,
7308 )
7309 .0)
7310 }
7311}
7312#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7313pub struct RootTextBindingOpt1Handle(pub(crate) super::tree::CstNodeId);
7314impl NonTerminalHandle for RootTextBindingOpt1Handle {
7315 type View = Option<GrammarNewlineHandle>;
7316 fn node_id(&self) -> CstNodeId {
7317 self.0
7318 }
7319 fn new_with_visit<F: CstFacade, E>(
7320 index: CstNodeId,
7321 tree: &F,
7322 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7323 ) -> Result<Self, CstConstructError<E>> {
7324 tree.collect_nodes(
7325 index,
7326 [NodeKind::NonTerminal(NonTerminalKind::RootTextBindingOpt1)],
7327 |[index], visit| Ok((Self(index), visit)),
7328 visit_ignored,
7329 )
7330 }
7331 fn kind(&self) -> NonTerminalKind {
7332 NonTerminalKind::RootTextBindingOpt1
7333 }
7334 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7335 &self,
7336 tree: &F,
7337 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7338 visit_ignored: &'v mut V,
7339 ) -> Result<O, CstConstructError<E>> {
7340 if tree.has_no_children(self.0) {
7341 return Ok(visit(None, visit_ignored).0);
7342 }
7343 Ok(visit(
7344 Some(GrammarNewlineHandle::new_with_visit(
7345 self.0,
7346 tree,
7347 visit_ignored,
7348 )?),
7349 visit_ignored,
7350 )
7351 .0)
7352 }
7353}
7354#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7355pub struct RootValueBindingHandle(pub(crate) super::tree::CstNodeId);
7356impl NonTerminalHandle for RootValueBindingHandle {
7357 type View = RootValueBindingView;
7358 fn node_id(&self) -> CstNodeId {
7359 self.0
7360 }
7361 fn new_with_visit<F: CstFacade, E>(
7362 index: CstNodeId,
7363 tree: &F,
7364 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7365 ) -> Result<Self, CstConstructError<E>> {
7366 tree.collect_nodes(
7367 index,
7368 [NodeKind::NonTerminal(NonTerminalKind::RootValueBinding)],
7369 |[index], visit| Ok((Self(index), visit)),
7370 visit_ignored,
7371 )
7372 }
7373 fn kind(&self) -> NonTerminalKind {
7374 NonTerminalKind::RootValueBinding
7375 }
7376 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7377 &self,
7378 tree: &F,
7379 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7380 visit_ignored: &'v mut V,
7381 ) -> Result<O, CstConstructError<E>> {
7382 tree.collect_nodes(
7383 self.0,
7384 [
7385 NodeKind::NonTerminal(NonTerminalKind::NewlineBind),
7386 NodeKind::NonTerminal(NonTerminalKind::Value),
7387 ],
7388 |[newline_bind, value], visit_ignored| {
7389 Ok(visit(
7390 RootValueBindingView {
7391 newline_bind: NewlineBindHandle(newline_bind),
7392 value: ValueHandle(value),
7393 },
7394 visit_ignored,
7395 ))
7396 },
7397 visit_ignored,
7398 )
7399 }
7400}
7401#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7402pub struct RootValueBindingView {
7403 pub newline_bind: NewlineBindHandle,
7404 pub value: ValueHandle,
7405}
7406impl RootValueBindingView {}
7407#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7408pub struct SQuoteHandle(pub(crate) super::tree::CstNodeId);
7409impl NonTerminalHandle for SQuoteHandle {
7410 type View = SQuoteView;
7411 fn node_id(&self) -> CstNodeId {
7412 self.0
7413 }
7414 fn new_with_visit<F: CstFacade, E>(
7415 index: CstNodeId,
7416 tree: &F,
7417 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7418 ) -> Result<Self, CstConstructError<E>> {
7419 tree.collect_nodes(
7420 index,
7421 [NodeKind::NonTerminal(NonTerminalKind::SQuote)],
7422 |[index], visit| Ok((Self(index), visit)),
7423 visit_ignored,
7424 )
7425 }
7426 fn kind(&self) -> NonTerminalKind {
7427 NonTerminalKind::SQuote
7428 }
7429 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7430 &self,
7431 tree: &F,
7432 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7433 visit_ignored: &'v mut V,
7434 ) -> Result<O, CstConstructError<E>> {
7435 tree.collect_nodes(
7436 self.0,
7437 [NodeKind::Terminal(TerminalKind::SQuote)],
7438 |[s_quote], visit_ignored| {
7439 Ok(visit(
7440 SQuoteView {
7441 s_quote: SQuote(s_quote),
7442 },
7443 visit_ignored,
7444 ))
7445 },
7446 visit_ignored,
7447 )
7448 }
7449}
7450#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7451pub struct SQuoteView {
7452 pub s_quote: SQuote,
7453}
7454impl SQuoteView {}
7455#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7456pub struct SectionHandle(pub(crate) super::tree::CstNodeId);
7457impl NonTerminalHandle for SectionHandle {
7458 type View = SectionView;
7459 fn node_id(&self) -> CstNodeId {
7460 self.0
7461 }
7462 fn new_with_visit<F: CstFacade, E>(
7463 index: CstNodeId,
7464 tree: &F,
7465 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7466 ) -> Result<Self, CstConstructError<E>> {
7467 tree.collect_nodes(
7468 index,
7469 [NodeKind::NonTerminal(NonTerminalKind::Section)],
7470 |[index], visit| Ok((Self(index), visit)),
7471 visit_ignored,
7472 )
7473 }
7474 fn kind(&self) -> NonTerminalKind {
7475 NonTerminalKind::Section
7476 }
7477 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7478 &self,
7479 tree: &F,
7480 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7481 visit_ignored: &'v mut V,
7482 ) -> Result<O, CstConstructError<E>> {
7483 tree.collect_nodes(
7484 self.0,
7485 [
7486 NodeKind::NonTerminal(NonTerminalKind::At),
7487 NodeKind::NonTerminal(NonTerminalKind::Keys),
7488 NodeKind::NonTerminal(NonTerminalKind::SectionBody),
7489 ],
7490 |[at, keys, section_body], visit_ignored| {
7491 Ok(visit(
7492 SectionView {
7493 at: AtHandle(at),
7494 keys: KeysHandle(keys),
7495 section_body: SectionBodyHandle(section_body),
7496 },
7497 visit_ignored,
7498 ))
7499 },
7500 visit_ignored,
7501 )
7502 }
7503}
7504#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7505pub struct SectionView {
7506 pub at: AtHandle,
7507 pub keys: KeysHandle,
7508 pub section_body: SectionBodyHandle,
7509}
7510impl SectionView {}
7511#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7512pub struct SectionBindingHandle(pub(crate) super::tree::CstNodeId);
7513impl NonTerminalHandle for SectionBindingHandle {
7514 type View = SectionBindingView;
7515 fn node_id(&self) -> CstNodeId {
7516 self.0
7517 }
7518 fn new_with_visit<F: CstFacade, E>(
7519 index: CstNodeId,
7520 tree: &F,
7521 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7522 ) -> Result<Self, CstConstructError<E>> {
7523 tree.collect_nodes(
7524 index,
7525 [NodeKind::NonTerminal(NonTerminalKind::SectionBinding)],
7526 |[index], visit| Ok((Self(index), visit)),
7527 visit_ignored,
7528 )
7529 }
7530 fn kind(&self) -> NonTerminalKind {
7531 NonTerminalKind::SectionBinding
7532 }
7533 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7534 &self,
7535 tree: &F,
7536 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7537 visit_ignored: &'v mut V,
7538 ) -> Result<O, CstConstructError<E>> {
7539 tree.collect_nodes(
7540 self.0,
7541 [
7542 NodeKind::NonTerminal(NonTerminalKind::Begin),
7543 NodeKind::NonTerminal(NonTerminalKind::Eure),
7544 NodeKind::NonTerminal(NonTerminalKind::End),
7545 ],
7546 |[begin, eure, end], visit_ignored| {
7547 Ok(visit(
7548 SectionBindingView {
7549 begin: BeginHandle(begin),
7550 eure: EureHandle(eure),
7551 end: EndHandle(end),
7552 },
7553 visit_ignored,
7554 ))
7555 },
7556 visit_ignored,
7557 )
7558 }
7559}
7560#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7561pub struct SectionBindingView {
7562 pub begin: BeginHandle,
7563 pub eure: EureHandle,
7564 pub end: EndHandle,
7565}
7566impl SectionBindingView {}
7567#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7568pub struct SectionBodyHandle(pub(crate) super::tree::CstNodeId);
7569impl NonTerminalHandle for SectionBodyHandle {
7570 type View = SectionBodyView;
7571 fn node_id(&self) -> CstNodeId {
7572 self.0
7573 }
7574 fn new_with_visit<F: CstFacade, E>(
7575 index: CstNodeId,
7576 tree: &F,
7577 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7578 ) -> Result<Self, CstConstructError<E>> {
7579 tree.collect_nodes(
7580 index,
7581 [NodeKind::NonTerminal(NonTerminalKind::SectionBody)],
7582 |[index], visit| Ok((Self(index), visit)),
7583 visit_ignored,
7584 )
7585 }
7586 fn kind(&self) -> NonTerminalKind {
7587 NonTerminalKind::SectionBody
7588 }
7589 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7590 &self,
7591 tree: &F,
7592 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7593 visit_ignored: &'v mut V,
7594 ) -> Result<O, CstConstructError<E>> {
7595 let mut children = tree.children(self.0);
7596 let Some(child) = children.next() else {
7597 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7598 };
7599 let Some(child_data) = tree.node_data(child) else {
7600 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7601 };
7602 let variant = match child_data.node_kind() {
7603 NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt) => {
7604 SectionBodyView::SectionBodyOpt(SectionBodyOptHandle(child))
7605 }
7606 NodeKind::NonTerminal(NonTerminalKind::BlockBody) => {
7607 SectionBodyView::BlockBody(BlockBodyHandle(child))
7608 }
7609 _ => {
7610 return Err(ViewConstructionError::UnexpectedNode {
7611 node: child,
7612 data: child_data,
7613 expected_kind: child_data.node_kind(),
7614 });
7615 }
7616 };
7617 let (result, _visit) = visit(variant, visit_ignored);
7618 if let Some(extra_child) = children.next() {
7619 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7620 }
7621 Ok(result)
7622 }
7623}
7624#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7625pub enum SectionBodyView {
7626 SectionBodyOpt(SectionBodyOptHandle),
7627 BlockBody(BlockBodyHandle),
7628}
7629impl SectionBodyView {}
7630#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7631pub struct SectionBodyOptHandle(pub(crate) super::tree::CstNodeId);
7632impl NonTerminalHandle for SectionBodyOptHandle {
7633 type View = Option<FlatBodyHandle>;
7634 fn node_id(&self) -> CstNodeId {
7635 self.0
7636 }
7637 fn new_with_visit<F: CstFacade, E>(
7638 index: CstNodeId,
7639 tree: &F,
7640 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7641 ) -> Result<Self, CstConstructError<E>> {
7642 tree.collect_nodes(
7643 index,
7644 [NodeKind::NonTerminal(NonTerminalKind::SectionBodyOpt)],
7645 |[index], visit| Ok((Self(index), visit)),
7646 visit_ignored,
7647 )
7648 }
7649 fn kind(&self) -> NonTerminalKind {
7650 NonTerminalKind::SectionBodyOpt
7651 }
7652 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7653 &self,
7654 tree: &F,
7655 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7656 visit_ignored: &'v mut V,
7657 ) -> Result<O, CstConstructError<E>> {
7658 if tree.has_no_children(self.0) {
7659 return Ok(visit(None, visit_ignored).0);
7660 }
7661 Ok(visit(
7662 Some(FlatBodyHandle::new_with_visit(self.0, tree, visit_ignored)?),
7663 visit_ignored,
7664 )
7665 .0)
7666 }
7667}
7668#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7669pub struct SectionHeadHandle(pub(crate) super::tree::CstNodeId);
7670impl NonTerminalHandle for SectionHeadHandle {
7671 type View = SectionHeadView;
7672 fn node_id(&self) -> CstNodeId {
7673 self.0
7674 }
7675 fn new_with_visit<F: CstFacade, E>(
7676 index: CstNodeId,
7677 tree: &F,
7678 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7679 ) -> Result<Self, CstConstructError<E>> {
7680 tree.collect_nodes(
7681 index,
7682 [NodeKind::NonTerminal(NonTerminalKind::SectionHead)],
7683 |[index], visit| Ok((Self(index), visit)),
7684 visit_ignored,
7685 )
7686 }
7687 fn kind(&self) -> NonTerminalKind {
7688 NonTerminalKind::SectionHead
7689 }
7690 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7691 &self,
7692 tree: &F,
7693 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7694 visit_ignored: &'v mut V,
7695 ) -> Result<O, CstConstructError<E>> {
7696 let mut children = tree.children(self.0);
7697 let Some(child) = children.next() else {
7698 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7699 };
7700 let Some(child_data) = tree.node_data(child) else {
7701 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7702 };
7703 let variant = match child_data.node_kind() {
7704 NodeKind::NonTerminal(NonTerminalKind::RootBinding) => {
7705 SectionHeadView::RootBinding(RootBindingHandle(child))
7706 }
7707 NodeKind::NonTerminal(NonTerminalKind::NewlineHead) => {
7708 SectionHeadView::NewlineHead(NewlineHeadHandle(child))
7709 }
7710 _ => {
7711 return Err(ViewConstructionError::UnexpectedNode {
7712 node: child,
7713 data: child_data,
7714 expected_kind: child_data.node_kind(),
7715 });
7716 }
7717 };
7718 let (result, _visit) = visit(variant, visit_ignored);
7719 if let Some(extra_child) = children.next() {
7720 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7721 }
7722 Ok(result)
7723 }
7724}
7725#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7726pub enum SectionHeadView {
7727 RootBinding(RootBindingHandle),
7728 NewlineHead(NewlineHeadHandle),
7729}
7730impl SectionHeadView {}
7731#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7732pub struct StrHandle(pub(crate) super::tree::CstNodeId);
7733impl NonTerminalHandle for StrHandle {
7734 type View = StrView;
7735 fn node_id(&self) -> CstNodeId {
7736 self.0
7737 }
7738 fn new_with_visit<F: CstFacade, E>(
7739 index: CstNodeId,
7740 tree: &F,
7741 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7742 ) -> Result<Self, CstConstructError<E>> {
7743 tree.collect_nodes(
7744 index,
7745 [NodeKind::NonTerminal(NonTerminalKind::Str)],
7746 |[index], visit| Ok((Self(index), visit)),
7747 visit_ignored,
7748 )
7749 }
7750 fn kind(&self) -> NonTerminalKind {
7751 NonTerminalKind::Str
7752 }
7753 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7754 &self,
7755 tree: &F,
7756 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7757 visit_ignored: &'v mut V,
7758 ) -> Result<O, CstConstructError<E>> {
7759 tree.collect_nodes(
7760 self.0,
7761 [NodeKind::Terminal(TerminalKind::Str)],
7762 |[str], visit_ignored| Ok(visit(StrView { str: Str(str) }, visit_ignored)),
7763 visit_ignored,
7764 )
7765 }
7766}
7767#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7768pub struct StrView {
7769 pub str: Str,
7770}
7771impl StrView {}
7772#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7773pub struct StringHandle(pub(crate) super::tree::CstNodeId);
7774impl NonTerminalHandle for StringHandle {
7775 type View = StringView;
7776 fn node_id(&self) -> CstNodeId {
7777 self.0
7778 }
7779 fn new_with_visit<F: CstFacade, E>(
7780 index: CstNodeId,
7781 tree: &F,
7782 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7783 ) -> Result<Self, CstConstructError<E>> {
7784 tree.collect_nodes(
7785 index,
7786 [NodeKind::NonTerminal(NonTerminalKind::String)],
7787 |[index], visit| Ok((Self(index), visit)),
7788 visit_ignored,
7789 )
7790 }
7791 fn kind(&self) -> NonTerminalKind {
7792 NonTerminalKind::String
7793 }
7794 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7795 &self,
7796 tree: &F,
7797 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7798 visit_ignored: &'v mut V,
7799 ) -> Result<O, CstConstructError<E>> {
7800 let mut children = tree.children(self.0);
7801 let Some(child) = children.next() else {
7802 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
7803 };
7804 let Some(child_data) = tree.node_data(child) else {
7805 return Err(ViewConstructionError::NodeIdNotFound { node: child });
7806 };
7807 let variant = match child_data.node_kind() {
7808 NodeKind::NonTerminal(NonTerminalKind::Str) => StringView::Str(StrHandle(child)),
7809 NodeKind::NonTerminal(NonTerminalKind::LitStr) => {
7810 StringView::LitStr(LitStrHandle(child))
7811 }
7812 NodeKind::NonTerminal(NonTerminalKind::LitStr1) => {
7813 StringView::LitStr1(LitStr1Handle(child))
7814 }
7815 NodeKind::NonTerminal(NonTerminalKind::LitStr2) => {
7816 StringView::LitStr2(LitStr2Handle(child))
7817 }
7818 NodeKind::NonTerminal(NonTerminalKind::LitStr3) => {
7819 StringView::LitStr3(LitStr3Handle(child))
7820 }
7821 _ => {
7822 return Err(ViewConstructionError::UnexpectedNode {
7823 node: child,
7824 data: child_data,
7825 expected_kind: child_data.node_kind(),
7826 });
7827 }
7828 };
7829 let (result, _visit) = visit(variant, visit_ignored);
7830 if let Some(extra_child) = children.next() {
7831 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
7832 }
7833 Ok(result)
7834 }
7835}
7836#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7837pub enum StringView {
7838 Str(StrHandle),
7839 LitStr(LitStrHandle),
7840 LitStr1(LitStr1Handle),
7841 LitStr2(LitStr2Handle),
7842 LitStr3(LitStr3Handle),
7843}
7844impl StringView {}
7845#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7846pub struct StringsHandle(pub(crate) super::tree::CstNodeId);
7847impl NonTerminalHandle for StringsHandle {
7848 type View = StringsView;
7849 fn node_id(&self) -> CstNodeId {
7850 self.0
7851 }
7852 fn new_with_visit<F: CstFacade, E>(
7853 index: CstNodeId,
7854 tree: &F,
7855 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7856 ) -> Result<Self, CstConstructError<E>> {
7857 tree.collect_nodes(
7858 index,
7859 [NodeKind::NonTerminal(NonTerminalKind::Strings)],
7860 |[index], visit| Ok((Self(index), visit)),
7861 visit_ignored,
7862 )
7863 }
7864 fn kind(&self) -> NonTerminalKind {
7865 NonTerminalKind::Strings
7866 }
7867 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7868 &self,
7869 tree: &F,
7870 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7871 visit_ignored: &'v mut V,
7872 ) -> Result<O, CstConstructError<E>> {
7873 tree.collect_nodes(
7874 self.0,
7875 [
7876 NodeKind::NonTerminal(NonTerminalKind::String),
7877 NodeKind::NonTerminal(NonTerminalKind::StringsList),
7878 ],
7879 |[string, strings_list], visit_ignored| {
7880 Ok(visit(
7881 StringsView {
7882 string: StringHandle(string),
7883 strings_list: StringsListHandle(strings_list),
7884 },
7885 visit_ignored,
7886 ))
7887 },
7888 visit_ignored,
7889 )
7890 }
7891}
7892#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7893pub struct StringsView {
7894 pub string: StringHandle,
7895 pub strings_list: StringsListHandle,
7896}
7897impl StringsView {}
7898#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7899pub struct StringsListHandle(pub(crate) super::tree::CstNodeId);
7900impl NonTerminalHandle for StringsListHandle {
7901 type View = Option<StringsListView>;
7902 fn node_id(&self) -> CstNodeId {
7903 self.0
7904 }
7905 fn new_with_visit<F: CstFacade, E>(
7906 index: CstNodeId,
7907 tree: &F,
7908 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7909 ) -> Result<Self, CstConstructError<E>> {
7910 tree.collect_nodes(
7911 index,
7912 [NodeKind::NonTerminal(NonTerminalKind::StringsList)],
7913 |[index], visit| Ok((Self(index), visit)),
7914 visit_ignored,
7915 )
7916 }
7917 fn kind(&self) -> NonTerminalKind {
7918 NonTerminalKind::StringsList
7919 }
7920 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
7921 &self,
7922 tree: &F,
7923 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
7924 visit_ignored: &'v mut V,
7925 ) -> Result<O, CstConstructError<E>> {
7926 if tree.has_no_children(self.0) {
7927 return Ok(visit(None, visit_ignored).0);
7928 }
7929 tree.collect_nodes(
7930 self.0,
7931 [
7932 NodeKind::NonTerminal(NonTerminalKind::Continue),
7933 NodeKind::NonTerminal(NonTerminalKind::String),
7934 NodeKind::NonTerminal(NonTerminalKind::StringsList),
7935 ],
7936 |[r#continue, string, strings_list], visit_ignored| {
7937 Ok(visit(
7938 Some(StringsListView {
7939 r#continue: ContinueHandle(r#continue),
7940 string: StringHandle(string),
7941 strings_list: StringsListHandle(strings_list),
7942 }),
7943 visit_ignored,
7944 ))
7945 },
7946 visit_ignored,
7947 )
7948 }
7949}
7950#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7951pub struct StringsListView {
7952 pub r#continue: ContinueHandle,
7953 pub string: StringHandle,
7954 pub strings_list: StringsListHandle,
7955}
7956impl<F: CstFacade> RecursiveView<F> for StringsListView {
7957 type Item = StringsListItem;
7958 fn get_all_with_visit<E>(
7959 &self,
7960 tree: &F,
7961 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7962 ) -> Result<Vec<Self::Item>, CstConstructError<E>> {
7963 let mut items = Vec::new();
7964 let mut current_view = Some(*self);
7965 while let Some(item) = current_view {
7966 let Self {
7967 r#continue, string, ..
7968 } = item;
7969 items.push(StringsListItem { r#continue, string });
7970 item.strings_list.get_view_with_visit(
7971 tree,
7972 |view, visit_ignored| {
7973 current_view = view;
7974 ((), visit_ignored)
7975 },
7976 visit_ignored,
7977 )?;
7978 }
7979 Ok(items)
7980 }
7981}
7982#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7983pub struct StringsListItem {
7984 pub r#continue: ContinueHandle,
7985 pub string: StringHandle,
7986}
7987#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
7988pub struct TextHandle(pub(crate) super::tree::CstNodeId);
7989impl NonTerminalHandle for TextHandle {
7990 type View = TextView;
7991 fn node_id(&self) -> CstNodeId {
7992 self.0
7993 }
7994 fn new_with_visit<F: CstFacade, E>(
7995 index: CstNodeId,
7996 tree: &F,
7997 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
7998 ) -> Result<Self, CstConstructError<E>> {
7999 tree.collect_nodes(
8000 index,
8001 [NodeKind::NonTerminal(NonTerminalKind::Text)],
8002 |[index], visit| Ok((Self(index), visit)),
8003 visit_ignored,
8004 )
8005 }
8006 fn kind(&self) -> NonTerminalKind {
8007 NonTerminalKind::Text
8008 }
8009 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8010 &self,
8011 tree: &F,
8012 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8013 visit_ignored: &'v mut V,
8014 ) -> Result<O, CstConstructError<E>> {
8015 tree.collect_nodes(
8016 self.0,
8017 [NodeKind::Terminal(TerminalKind::Text)],
8018 |[text], visit_ignored| Ok(visit(TextView { text: Text(text) }, visit_ignored)),
8019 visit_ignored,
8020 )
8021 }
8022}
8023#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8024pub struct TextView {
8025 pub text: Text,
8026}
8027impl TextView {}
8028#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8029pub struct TextBindingHandle(pub(crate) super::tree::CstNodeId);
8030impl NonTerminalHandle for TextBindingHandle {
8031 type View = TextBindingView;
8032 fn node_id(&self) -> CstNodeId {
8033 self.0
8034 }
8035 fn new_with_visit<F: CstFacade, E>(
8036 index: CstNodeId,
8037 tree: &F,
8038 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8039 ) -> Result<Self, CstConstructError<E>> {
8040 tree.collect_nodes(
8041 index,
8042 [NodeKind::NonTerminal(NonTerminalKind::TextBinding)],
8043 |[index], visit| Ok((Self(index), visit)),
8044 visit_ignored,
8045 )
8046 }
8047 fn kind(&self) -> NonTerminalKind {
8048 NonTerminalKind::TextBinding
8049 }
8050 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8051 &self,
8052 tree: &F,
8053 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8054 visit_ignored: &'v mut V,
8055 ) -> Result<O, CstConstructError<E>> {
8056 tree.collect_nodes(
8057 self.0,
8058 [
8059 NodeKind::NonTerminal(NonTerminalKind::TextStart),
8060 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt),
8061 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0),
8062 NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt1),
8063 ],
8064 |[
8065 text_start,
8066 text_binding_opt,
8067 text_binding_opt_0,
8068 text_binding_opt_1,
8069 ],
8070 visit_ignored| {
8071 Ok(visit(
8072 TextBindingView {
8073 text_start: TextStartHandle(text_start),
8074 text_binding_opt: TextBindingOptHandle(text_binding_opt),
8075 text_binding_opt_0: TextBindingOpt0Handle(text_binding_opt_0),
8076 text_binding_opt_1: TextBindingOpt1Handle(text_binding_opt_1),
8077 },
8078 visit_ignored,
8079 ))
8080 },
8081 visit_ignored,
8082 )
8083 }
8084}
8085#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8086pub struct TextBindingView {
8087 pub text_start: TextStartHandle,
8088 pub text_binding_opt: TextBindingOptHandle,
8089 pub text_binding_opt_0: TextBindingOpt0Handle,
8090 pub text_binding_opt_1: TextBindingOpt1Handle,
8091}
8092impl TextBindingView {}
8093#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8094pub struct TextBindingOptHandle(pub(crate) super::tree::CstNodeId);
8095impl NonTerminalHandle for TextBindingOptHandle {
8096 type View = Option<WsHandle>;
8097 fn node_id(&self) -> CstNodeId {
8098 self.0
8099 }
8100 fn new_with_visit<F: CstFacade, E>(
8101 index: CstNodeId,
8102 tree: &F,
8103 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8104 ) -> Result<Self, CstConstructError<E>> {
8105 tree.collect_nodes(
8106 index,
8107 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt)],
8108 |[index], visit| Ok((Self(index), visit)),
8109 visit_ignored,
8110 )
8111 }
8112 fn kind(&self) -> NonTerminalKind {
8113 NonTerminalKind::TextBindingOpt
8114 }
8115 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8116 &self,
8117 tree: &F,
8118 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8119 visit_ignored: &'v mut V,
8120 ) -> Result<O, CstConstructError<E>> {
8121 if tree.has_no_children(self.0) {
8122 return Ok(visit(None, visit_ignored).0);
8123 }
8124 Ok(visit(
8125 Some(WsHandle::new_with_visit(self.0, tree, visit_ignored)?),
8126 visit_ignored,
8127 )
8128 .0)
8129 }
8130}
8131#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8132pub struct TextBindingOpt0Handle(pub(crate) super::tree::CstNodeId);
8133impl NonTerminalHandle for TextBindingOpt0Handle {
8134 type View = Option<TextHandle>;
8135 fn node_id(&self) -> CstNodeId {
8136 self.0
8137 }
8138 fn new_with_visit<F: CstFacade, E>(
8139 index: CstNodeId,
8140 tree: &F,
8141 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8142 ) -> Result<Self, CstConstructError<E>> {
8143 tree.collect_nodes(
8144 index,
8145 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt0)],
8146 |[index], visit| Ok((Self(index), visit)),
8147 visit_ignored,
8148 )
8149 }
8150 fn kind(&self) -> NonTerminalKind {
8151 NonTerminalKind::TextBindingOpt0
8152 }
8153 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8154 &self,
8155 tree: &F,
8156 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8157 visit_ignored: &'v mut V,
8158 ) -> Result<O, CstConstructError<E>> {
8159 if tree.has_no_children(self.0) {
8160 return Ok(visit(None, visit_ignored).0);
8161 }
8162 Ok(visit(
8163 Some(TextHandle::new_with_visit(self.0, tree, visit_ignored)?),
8164 visit_ignored,
8165 )
8166 .0)
8167 }
8168}
8169#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8170pub struct TextBindingOpt1Handle(pub(crate) super::tree::CstNodeId);
8171impl NonTerminalHandle for TextBindingOpt1Handle {
8172 type View = Option<GrammarNewlineHandle>;
8173 fn node_id(&self) -> CstNodeId {
8174 self.0
8175 }
8176 fn new_with_visit<F: CstFacade, E>(
8177 index: CstNodeId,
8178 tree: &F,
8179 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8180 ) -> Result<Self, CstConstructError<E>> {
8181 tree.collect_nodes(
8182 index,
8183 [NodeKind::NonTerminal(NonTerminalKind::TextBindingOpt1)],
8184 |[index], visit| Ok((Self(index), visit)),
8185 visit_ignored,
8186 )
8187 }
8188 fn kind(&self) -> NonTerminalKind {
8189 NonTerminalKind::TextBindingOpt1
8190 }
8191 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8192 &self,
8193 tree: &F,
8194 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8195 visit_ignored: &'v mut V,
8196 ) -> Result<O, CstConstructError<E>> {
8197 if tree.has_no_children(self.0) {
8198 return Ok(visit(None, visit_ignored).0);
8199 }
8200 Ok(visit(
8201 Some(GrammarNewlineHandle::new_with_visit(
8202 self.0,
8203 tree,
8204 visit_ignored,
8205 )?),
8206 visit_ignored,
8207 )
8208 .0)
8209 }
8210}
8211#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8212pub struct TextStartHandle(pub(crate) super::tree::CstNodeId);
8213impl NonTerminalHandle for TextStartHandle {
8214 type View = TextStartView;
8215 fn node_id(&self) -> CstNodeId {
8216 self.0
8217 }
8218 fn new_with_visit<F: CstFacade, E>(
8219 index: CstNodeId,
8220 tree: &F,
8221 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8222 ) -> Result<Self, CstConstructError<E>> {
8223 tree.collect_nodes(
8224 index,
8225 [NodeKind::NonTerminal(NonTerminalKind::TextStart)],
8226 |[index], visit| Ok((Self(index), visit)),
8227 visit_ignored,
8228 )
8229 }
8230 fn kind(&self) -> NonTerminalKind {
8231 NonTerminalKind::TextStart
8232 }
8233 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8234 &self,
8235 tree: &F,
8236 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8237 visit_ignored: &'v mut V,
8238 ) -> Result<O, CstConstructError<E>> {
8239 tree.collect_nodes(
8240 self.0,
8241 [NodeKind::Terminal(TerminalKind::TextStart)],
8242 |[text_start], visit_ignored| {
8243 Ok(visit(
8244 TextStartView {
8245 text_start: TextStart(text_start),
8246 },
8247 visit_ignored,
8248 ))
8249 },
8250 visit_ignored,
8251 )
8252 }
8253}
8254#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8255pub struct TextStartView {
8256 pub text_start: TextStart,
8257}
8258impl TextStartView {}
8259#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8260pub struct TopLevelBindingHandle(pub(crate) super::tree::CstNodeId);
8261impl NonTerminalHandle for TopLevelBindingHandle {
8262 type View = TopLevelBindingView;
8263 fn node_id(&self) -> CstNodeId {
8264 self.0
8265 }
8266 fn new_with_visit<F: CstFacade, E>(
8267 index: CstNodeId,
8268 tree: &F,
8269 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8270 ) -> Result<Self, CstConstructError<E>> {
8271 tree.collect_nodes(
8272 index,
8273 [NodeKind::NonTerminal(NonTerminalKind::TopLevelBinding)],
8274 |[index], visit| Ok((Self(index), visit)),
8275 visit_ignored,
8276 )
8277 }
8278 fn kind(&self) -> NonTerminalKind {
8279 NonTerminalKind::TopLevelBinding
8280 }
8281 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8282 &self,
8283 tree: &F,
8284 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8285 visit_ignored: &'v mut V,
8286 ) -> Result<O, CstConstructError<E>> {
8287 let mut children = tree.children(self.0);
8288 let Some(child) = children.next() else {
8289 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
8290 };
8291 let Some(child_data) = tree.node_data(child) else {
8292 return Err(ViewConstructionError::NodeIdNotFound { node: child });
8293 };
8294 let variant = match child_data.node_kind() {
8295 NodeKind::NonTerminal(NonTerminalKind::ValueBinding) => {
8296 TopLevelBindingView::ValueBinding(ValueBindingHandle(child))
8297 }
8298 NodeKind::NonTerminal(NonTerminalKind::TextBinding) => {
8299 TopLevelBindingView::TextBinding(TextBindingHandle(child))
8300 }
8301 _ => {
8302 return Err(ViewConstructionError::UnexpectedNode {
8303 node: child,
8304 data: child_data,
8305 expected_kind: child_data.node_kind(),
8306 });
8307 }
8308 };
8309 let (result, _visit) = visit(variant, visit_ignored);
8310 if let Some(extra_child) = children.next() {
8311 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
8312 }
8313 Ok(result)
8314 }
8315}
8316#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8317pub enum TopLevelBindingView {
8318 ValueBinding(ValueBindingHandle),
8319 TextBinding(TextBindingHandle),
8320}
8321impl TopLevelBindingView {}
8322#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8323pub struct TrueHandle(pub(crate) super::tree::CstNodeId);
8324impl NonTerminalHandle for TrueHandle {
8325 type View = TrueView;
8326 fn node_id(&self) -> CstNodeId {
8327 self.0
8328 }
8329 fn new_with_visit<F: CstFacade, E>(
8330 index: CstNodeId,
8331 tree: &F,
8332 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8333 ) -> Result<Self, CstConstructError<E>> {
8334 tree.collect_nodes(
8335 index,
8336 [NodeKind::NonTerminal(NonTerminalKind::True)],
8337 |[index], visit| Ok((Self(index), visit)),
8338 visit_ignored,
8339 )
8340 }
8341 fn kind(&self) -> NonTerminalKind {
8342 NonTerminalKind::True
8343 }
8344 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8345 &self,
8346 tree: &F,
8347 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8348 visit_ignored: &'v mut V,
8349 ) -> Result<O, CstConstructError<E>> {
8350 tree.collect_nodes(
8351 self.0,
8352 [NodeKind::Terminal(TerminalKind::True)],
8353 |[r#true], visit_ignored| {
8354 Ok(visit(
8355 TrueView {
8356 r#true: True(r#true),
8357 },
8358 visit_ignored,
8359 ))
8360 },
8361 visit_ignored,
8362 )
8363 }
8364}
8365#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8366pub struct TrueView {
8367 pub r#true: True,
8368}
8369impl TrueView {}
8370#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8371pub struct TupleHandle(pub(crate) super::tree::CstNodeId);
8372impl NonTerminalHandle for TupleHandle {
8373 type View = TupleView;
8374 fn node_id(&self) -> CstNodeId {
8375 self.0
8376 }
8377 fn new_with_visit<F: CstFacade, E>(
8378 index: CstNodeId,
8379 tree: &F,
8380 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8381 ) -> Result<Self, CstConstructError<E>> {
8382 tree.collect_nodes(
8383 index,
8384 [NodeKind::NonTerminal(NonTerminalKind::Tuple)],
8385 |[index], visit| Ok((Self(index), visit)),
8386 visit_ignored,
8387 )
8388 }
8389 fn kind(&self) -> NonTerminalKind {
8390 NonTerminalKind::Tuple
8391 }
8392 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8393 &self,
8394 tree: &F,
8395 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8396 visit_ignored: &'v mut V,
8397 ) -> Result<O, CstConstructError<E>> {
8398 tree.collect_nodes(
8399 self.0,
8400 [
8401 NodeKind::NonTerminal(NonTerminalKind::LParen),
8402 NodeKind::NonTerminal(NonTerminalKind::TupleOpt),
8403 NodeKind::NonTerminal(NonTerminalKind::RParen),
8404 ],
8405 |[l_paren, tuple_opt, r_paren], visit_ignored| {
8406 Ok(visit(
8407 TupleView {
8408 l_paren: LParenHandle(l_paren),
8409 tuple_opt: TupleOptHandle(tuple_opt),
8410 r_paren: RParenHandle(r_paren),
8411 },
8412 visit_ignored,
8413 ))
8414 },
8415 visit_ignored,
8416 )
8417 }
8418}
8419#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8420pub struct TupleView {
8421 pub l_paren: LParenHandle,
8422 pub tuple_opt: TupleOptHandle,
8423 pub r_paren: RParenHandle,
8424}
8425impl TupleView {}
8426#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8427pub struct TupleElementsHandle(pub(crate) super::tree::CstNodeId);
8428impl NonTerminalHandle for TupleElementsHandle {
8429 type View = TupleElementsView;
8430 fn node_id(&self) -> CstNodeId {
8431 self.0
8432 }
8433 fn new_with_visit<F: CstFacade, E>(
8434 index: CstNodeId,
8435 tree: &F,
8436 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8437 ) -> Result<Self, CstConstructError<E>> {
8438 tree.collect_nodes(
8439 index,
8440 [NodeKind::NonTerminal(NonTerminalKind::TupleElements)],
8441 |[index], visit| Ok((Self(index), visit)),
8442 visit_ignored,
8443 )
8444 }
8445 fn kind(&self) -> NonTerminalKind {
8446 NonTerminalKind::TupleElements
8447 }
8448 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8449 &self,
8450 tree: &F,
8451 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8452 visit_ignored: &'v mut V,
8453 ) -> Result<O, CstConstructError<E>> {
8454 tree.collect_nodes(
8455 self.0,
8456 [
8457 NodeKind::NonTerminal(NonTerminalKind::Value),
8458 NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt),
8459 ],
8460 |[value, tuple_elements_opt], visit_ignored| {
8461 Ok(visit(
8462 TupleElementsView {
8463 value: ValueHandle(value),
8464 tuple_elements_opt: TupleElementsOptHandle(tuple_elements_opt),
8465 },
8466 visit_ignored,
8467 ))
8468 },
8469 visit_ignored,
8470 )
8471 }
8472}
8473#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8474pub struct TupleElementsView {
8475 pub value: ValueHandle,
8476 pub tuple_elements_opt: TupleElementsOptHandle,
8477}
8478impl TupleElementsView {}
8479#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8480pub struct TupleElementsOptHandle(pub(crate) super::tree::CstNodeId);
8481impl NonTerminalHandle for TupleElementsOptHandle {
8482 type View = Option<TupleElementsTailHandle>;
8483 fn node_id(&self) -> CstNodeId {
8484 self.0
8485 }
8486 fn new_with_visit<F: CstFacade, E>(
8487 index: CstNodeId,
8488 tree: &F,
8489 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8490 ) -> Result<Self, CstConstructError<E>> {
8491 tree.collect_nodes(
8492 index,
8493 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsOpt)],
8494 |[index], visit| Ok((Self(index), visit)),
8495 visit_ignored,
8496 )
8497 }
8498 fn kind(&self) -> NonTerminalKind {
8499 NonTerminalKind::TupleElementsOpt
8500 }
8501 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8502 &self,
8503 tree: &F,
8504 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8505 visit_ignored: &'v mut V,
8506 ) -> Result<O, CstConstructError<E>> {
8507 if tree.has_no_children(self.0) {
8508 return Ok(visit(None, visit_ignored).0);
8509 }
8510 Ok(visit(
8511 Some(TupleElementsTailHandle::new_with_visit(
8512 self.0,
8513 tree,
8514 visit_ignored,
8515 )?),
8516 visit_ignored,
8517 )
8518 .0)
8519 }
8520}
8521#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8522pub struct TupleElementsTailHandle(pub(crate) super::tree::CstNodeId);
8523impl NonTerminalHandle for TupleElementsTailHandle {
8524 type View = TupleElementsTailView;
8525 fn node_id(&self) -> CstNodeId {
8526 self.0
8527 }
8528 fn new_with_visit<F: CstFacade, E>(
8529 index: CstNodeId,
8530 tree: &F,
8531 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8532 ) -> Result<Self, CstConstructError<E>> {
8533 tree.collect_nodes(
8534 index,
8535 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTail)],
8536 |[index], visit| Ok((Self(index), visit)),
8537 visit_ignored,
8538 )
8539 }
8540 fn kind(&self) -> NonTerminalKind {
8541 NonTerminalKind::TupleElementsTail
8542 }
8543 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8544 &self,
8545 tree: &F,
8546 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8547 visit_ignored: &'v mut V,
8548 ) -> Result<O, CstConstructError<E>> {
8549 tree.collect_nodes(
8550 self.0,
8551 [
8552 NodeKind::NonTerminal(NonTerminalKind::Comma),
8553 NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt),
8554 ],
8555 |[comma, tuple_elements_tail_opt], visit_ignored| {
8556 Ok(visit(
8557 TupleElementsTailView {
8558 comma: CommaHandle(comma),
8559 tuple_elements_tail_opt: TupleElementsTailOptHandle(
8560 tuple_elements_tail_opt,
8561 ),
8562 },
8563 visit_ignored,
8564 ))
8565 },
8566 visit_ignored,
8567 )
8568 }
8569}
8570#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8571pub struct TupleElementsTailView {
8572 pub comma: CommaHandle,
8573 pub tuple_elements_tail_opt: TupleElementsTailOptHandle,
8574}
8575impl TupleElementsTailView {}
8576#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8577pub struct TupleElementsTailOptHandle(pub(crate) super::tree::CstNodeId);
8578impl NonTerminalHandle for TupleElementsTailOptHandle {
8579 type View = Option<TupleElementsHandle>;
8580 fn node_id(&self) -> CstNodeId {
8581 self.0
8582 }
8583 fn new_with_visit<F: CstFacade, E>(
8584 index: CstNodeId,
8585 tree: &F,
8586 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8587 ) -> Result<Self, CstConstructError<E>> {
8588 tree.collect_nodes(
8589 index,
8590 [NodeKind::NonTerminal(NonTerminalKind::TupleElementsTailOpt)],
8591 |[index], visit| Ok((Self(index), visit)),
8592 visit_ignored,
8593 )
8594 }
8595 fn kind(&self) -> NonTerminalKind {
8596 NonTerminalKind::TupleElementsTailOpt
8597 }
8598 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8599 &self,
8600 tree: &F,
8601 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8602 visit_ignored: &'v mut V,
8603 ) -> Result<O, CstConstructError<E>> {
8604 if tree.has_no_children(self.0) {
8605 return Ok(visit(None, visit_ignored).0);
8606 }
8607 Ok(visit(
8608 Some(TupleElementsHandle::new_with_visit(
8609 self.0,
8610 tree,
8611 visit_ignored,
8612 )?),
8613 visit_ignored,
8614 )
8615 .0)
8616 }
8617}
8618#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8619pub struct TupleIndexHandle(pub(crate) super::tree::CstNodeId);
8620impl NonTerminalHandle for TupleIndexHandle {
8621 type View = TupleIndexView;
8622 fn node_id(&self) -> CstNodeId {
8623 self.0
8624 }
8625 fn new_with_visit<F: CstFacade, E>(
8626 index: CstNodeId,
8627 tree: &F,
8628 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8629 ) -> Result<Self, CstConstructError<E>> {
8630 tree.collect_nodes(
8631 index,
8632 [NodeKind::NonTerminal(NonTerminalKind::TupleIndex)],
8633 |[index], visit| Ok((Self(index), visit)),
8634 visit_ignored,
8635 )
8636 }
8637 fn kind(&self) -> NonTerminalKind {
8638 NonTerminalKind::TupleIndex
8639 }
8640 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8641 &self,
8642 tree: &F,
8643 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8644 visit_ignored: &'v mut V,
8645 ) -> Result<O, CstConstructError<E>> {
8646 tree.collect_nodes(
8647 self.0,
8648 [
8649 NodeKind::Terminal(TerminalKind::Hash),
8650 NodeKind::NonTerminal(NonTerminalKind::Integer),
8651 ],
8652 |[hash, integer], visit_ignored| {
8653 Ok(visit(
8654 TupleIndexView {
8655 hash: Hash(hash),
8656 integer: IntegerHandle(integer),
8657 },
8658 visit_ignored,
8659 ))
8660 },
8661 visit_ignored,
8662 )
8663 }
8664}
8665#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8666pub struct TupleIndexView {
8667 pub hash: Hash,
8668 pub integer: IntegerHandle,
8669}
8670impl TupleIndexView {}
8671#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8672pub struct TupleOptHandle(pub(crate) super::tree::CstNodeId);
8673impl NonTerminalHandle for TupleOptHandle {
8674 type View = Option<TupleElementsHandle>;
8675 fn node_id(&self) -> CstNodeId {
8676 self.0
8677 }
8678 fn new_with_visit<F: CstFacade, E>(
8679 index: CstNodeId,
8680 tree: &F,
8681 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8682 ) -> Result<Self, CstConstructError<E>> {
8683 tree.collect_nodes(
8684 index,
8685 [NodeKind::NonTerminal(NonTerminalKind::TupleOpt)],
8686 |[index], visit| Ok((Self(index), visit)),
8687 visit_ignored,
8688 )
8689 }
8690 fn kind(&self) -> NonTerminalKind {
8691 NonTerminalKind::TupleOpt
8692 }
8693 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8694 &self,
8695 tree: &F,
8696 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8697 visit_ignored: &'v mut V,
8698 ) -> Result<O, CstConstructError<E>> {
8699 if tree.has_no_children(self.0) {
8700 return Ok(visit(None, visit_ignored).0);
8701 }
8702 Ok(visit(
8703 Some(TupleElementsHandle::new_with_visit(
8704 self.0,
8705 tree,
8706 visit_ignored,
8707 )?),
8708 visit_ignored,
8709 )
8710 .0)
8711 }
8712}
8713#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8714pub struct ValueHandle(pub(crate) super::tree::CstNodeId);
8715impl NonTerminalHandle for ValueHandle {
8716 type View = ValueView;
8717 fn node_id(&self) -> CstNodeId {
8718 self.0
8719 }
8720 fn new_with_visit<F: CstFacade, E>(
8721 index: CstNodeId,
8722 tree: &F,
8723 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8724 ) -> Result<Self, CstConstructError<E>> {
8725 tree.collect_nodes(
8726 index,
8727 [NodeKind::NonTerminal(NonTerminalKind::Value)],
8728 |[index], visit| Ok((Self(index), visit)),
8729 visit_ignored,
8730 )
8731 }
8732 fn kind(&self) -> NonTerminalKind {
8733 NonTerminalKind::Value
8734 }
8735 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8736 &self,
8737 tree: &F,
8738 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8739 visit_ignored: &'v mut V,
8740 ) -> Result<O, CstConstructError<E>> {
8741 let mut children = tree.children(self.0);
8742 let Some(child) = children.next() else {
8743 return Err(ViewConstructionError::UnexpectedEndOfChildren { parent: self.0 });
8744 };
8745 let Some(child_data) = tree.node_data(child) else {
8746 return Err(ViewConstructionError::NodeIdNotFound { node: child });
8747 };
8748 let variant = match child_data.node_kind() {
8749 NodeKind::NonTerminal(NonTerminalKind::Object) => {
8750 ValueView::Object(ObjectHandle(child))
8751 }
8752 NodeKind::NonTerminal(NonTerminalKind::Array) => ValueView::Array(ArrayHandle(child)),
8753 NodeKind::NonTerminal(NonTerminalKind::Tuple) => ValueView::Tuple(TupleHandle(child)),
8754 NodeKind::NonTerminal(NonTerminalKind::Number) => {
8755 ValueView::Number(NumberHandle(child))
8756 }
8757 NodeKind::NonTerminal(NonTerminalKind::Boolean) => {
8758 ValueView::Boolean(BooleanHandle(child))
8759 }
8760 NodeKind::NonTerminal(NonTerminalKind::Null) => ValueView::Null(NullHandle(child)),
8761 NodeKind::NonTerminal(NonTerminalKind::Strings) => {
8762 ValueView::Strings(StringsHandle(child))
8763 }
8764 NodeKind::NonTerminal(NonTerminalKind::Hole) => ValueView::Hole(HoleHandle(child)),
8765 NodeKind::NonTerminal(NonTerminalKind::CodeBlock) => {
8766 ValueView::CodeBlock(CodeBlockHandle(child))
8767 }
8768 NodeKind::NonTerminal(NonTerminalKind::InlineCode) => {
8769 ValueView::InlineCode(InlineCodeHandle(child))
8770 }
8771 _ => {
8772 return Err(ViewConstructionError::UnexpectedNode {
8773 node: child,
8774 data: child_data,
8775 expected_kind: child_data.node_kind(),
8776 });
8777 }
8778 };
8779 let (result, _visit) = visit(variant, visit_ignored);
8780 if let Some(extra_child) = children.next() {
8781 return Err(ViewConstructionError::UnexpectedExtraNode { node: extra_child });
8782 }
8783 Ok(result)
8784 }
8785}
8786#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8787pub enum ValueView {
8788 Object(ObjectHandle),
8789 Array(ArrayHandle),
8790 Tuple(TupleHandle),
8791 Number(NumberHandle),
8792 Boolean(BooleanHandle),
8793 Null(NullHandle),
8794 Strings(StringsHandle),
8795 Hole(HoleHandle),
8796 CodeBlock(CodeBlockHandle),
8797 InlineCode(InlineCodeHandle),
8798}
8799impl ValueView {}
8800#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8801pub struct ValueBindingHandle(pub(crate) super::tree::CstNodeId);
8802impl NonTerminalHandle for ValueBindingHandle {
8803 type View = ValueBindingView;
8804 fn node_id(&self) -> CstNodeId {
8805 self.0
8806 }
8807 fn new_with_visit<F: CstFacade, E>(
8808 index: CstNodeId,
8809 tree: &F,
8810 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8811 ) -> Result<Self, CstConstructError<E>> {
8812 tree.collect_nodes(
8813 index,
8814 [NodeKind::NonTerminal(NonTerminalKind::ValueBinding)],
8815 |[index], visit| Ok((Self(index), visit)),
8816 visit_ignored,
8817 )
8818 }
8819 fn kind(&self) -> NonTerminalKind {
8820 NonTerminalKind::ValueBinding
8821 }
8822 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8823 &self,
8824 tree: &F,
8825 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8826 visit_ignored: &'v mut V,
8827 ) -> Result<O, CstConstructError<E>> {
8828 tree.collect_nodes(
8829 self.0,
8830 [
8831 NodeKind::NonTerminal(NonTerminalKind::Bind),
8832 NodeKind::NonTerminal(NonTerminalKind::Value),
8833 ],
8834 |[bind, value], visit_ignored| {
8835 Ok(visit(
8836 ValueBindingView {
8837 bind: BindHandle(bind),
8838 value: ValueHandle(value),
8839 },
8840 visit_ignored,
8841 ))
8842 },
8843 visit_ignored,
8844 )
8845 }
8846}
8847#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8848pub struct ValueBindingView {
8849 pub bind: BindHandle,
8850 pub value: ValueHandle,
8851}
8852impl ValueBindingView {}
8853#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8854pub struct WsHandle(pub(crate) super::tree::CstNodeId);
8855impl NonTerminalHandle for WsHandle {
8856 type View = WsView;
8857 fn node_id(&self) -> CstNodeId {
8858 self.0
8859 }
8860 fn new_with_visit<F: CstFacade, E>(
8861 index: CstNodeId,
8862 tree: &F,
8863 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8864 ) -> Result<Self, CstConstructError<E>> {
8865 tree.collect_nodes(
8866 index,
8867 [NodeKind::NonTerminal(NonTerminalKind::Ws)],
8868 |[index], visit| Ok((Self(index), visit)),
8869 visit_ignored,
8870 )
8871 }
8872 fn kind(&self) -> NonTerminalKind {
8873 NonTerminalKind::Ws
8874 }
8875 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8876 &self,
8877 tree: &F,
8878 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8879 visit_ignored: &'v mut V,
8880 ) -> Result<O, CstConstructError<E>> {
8881 tree.collect_nodes(
8882 self.0,
8883 [NodeKind::Terminal(TerminalKind::Ws)],
8884 |[ws], visit_ignored| Ok(visit(WsView { ws: Ws(ws) }, visit_ignored)),
8885 visit_ignored,
8886 )
8887 }
8888}
8889#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8890pub struct WsView {
8891 pub ws: Ws,
8892}
8893impl WsView {}
8894#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
8895pub struct RootHandle(pub(crate) super::tree::CstNodeId);
8896impl NonTerminalHandle for RootHandle {
8897 type View = RootView;
8898 fn node_id(&self) -> CstNodeId {
8899 self.0
8900 }
8901 fn new_with_visit<F: CstFacade, E>(
8902 index: CstNodeId,
8903 tree: &F,
8904 visit_ignored: &mut impl BuiltinTerminalVisitor<E, F>,
8905 ) -> Result<Self, CstConstructError<E>> {
8906 tree.collect_nodes(
8907 index,
8908 [NodeKind::NonTerminal(NonTerminalKind::Root)],
8909 |[index], visit| Ok((Self(index), visit)),
8910 visit_ignored,
8911 )
8912 }
8913 fn kind(&self) -> NonTerminalKind {
8914 NonTerminalKind::Root
8915 }
8916 fn get_view_with_visit<'v, F: CstFacade, V: BuiltinTerminalVisitor<E, F>, O, E>(
8917 &self,
8918 tree: &F,
8919 mut visit: impl FnMut(Self::View, &'v mut V) -> (O, &'v mut V),
8920 visit_ignored: &'v mut V,
8921 ) -> Result<O, CstConstructError<E>> {
8922 tree.collect_nodes(
8923 self.0,
8924 [NodeKind::NonTerminal(NonTerminalKind::Eure)],
8925 |[eure], visit_ignored| {
8926 Ok(visit(
8927 RootView {
8928 eure: EureHandle(eure),
8929 },
8930 visit_ignored,
8931 ))
8932 },
8933 visit_ignored,
8934 )
8935 }
8936}
8937#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8938pub struct RootView {
8939 pub eure: EureHandle,
8940}
8941impl RootView {}
8942#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8943pub struct NewLine(pub(crate) super::tree::CstNodeId);
8944impl TerminalHandle for NewLine {
8945 fn node_id(&self) -> CstNodeId {
8946 self.0
8947 }
8948 fn kind(&self) -> TerminalKind {
8949 TerminalKind::NewLine
8950 }
8951}
8952#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8953pub struct Whitespace(pub(crate) super::tree::CstNodeId);
8954impl TerminalHandle for Whitespace {
8955 fn node_id(&self) -> CstNodeId {
8956 self.0
8957 }
8958 fn kind(&self) -> TerminalKind {
8959 TerminalKind::Whitespace
8960 }
8961}
8962#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8963pub struct LineComment(pub(crate) super::tree::CstNodeId);
8964impl TerminalHandle for LineComment {
8965 fn node_id(&self) -> CstNodeId {
8966 self.0
8967 }
8968 fn kind(&self) -> TerminalKind {
8969 TerminalKind::LineComment
8970 }
8971}
8972#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8973pub struct BlockComment(pub(crate) super::tree::CstNodeId);
8974impl TerminalHandle for BlockComment {
8975 fn node_id(&self) -> CstNodeId {
8976 self.0
8977 }
8978 fn kind(&self) -> TerminalKind {
8979 TerminalKind::BlockComment
8980 }
8981}
8982#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8983pub struct Hash(pub(crate) super::tree::CstNodeId);
8984impl TerminalHandle for Hash {
8985 fn node_id(&self) -> CstNodeId {
8986 self.0
8987 }
8988 fn kind(&self) -> TerminalKind {
8989 TerminalKind::Hash
8990 }
8991}
8992#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8993pub struct MapBind(pub(crate) super::tree::CstNodeId);
8994impl TerminalHandle for MapBind {
8995 fn node_id(&self) -> CstNodeId {
8996 self.0
8997 }
8998 fn kind(&self) -> TerminalKind {
8999 TerminalKind::MapBind
9000 }
9001}
9002#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9003pub struct Integer(pub(crate) super::tree::CstNodeId);
9004impl TerminalHandle for Integer {
9005 fn node_id(&self) -> CstNodeId {
9006 self.0
9007 }
9008 fn kind(&self) -> TerminalKind {
9009 TerminalKind::Integer
9010 }
9011}
9012#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9013pub struct Float(pub(crate) super::tree::CstNodeId);
9014impl TerminalHandle for Float {
9015 fn node_id(&self) -> CstNodeId {
9016 self.0
9017 }
9018 fn kind(&self) -> TerminalKind {
9019 TerminalKind::Float
9020 }
9021}
9022#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9023pub struct Inf(pub(crate) super::tree::CstNodeId);
9024impl TerminalHandle for Inf {
9025 fn node_id(&self) -> CstNodeId {
9026 self.0
9027 }
9028 fn kind(&self) -> TerminalKind {
9029 TerminalKind::Inf
9030 }
9031}
9032#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9033pub struct NaN(pub(crate) super::tree::CstNodeId);
9034impl TerminalHandle for NaN {
9035 fn node_id(&self) -> CstNodeId {
9036 self.0
9037 }
9038 fn kind(&self) -> TerminalKind {
9039 TerminalKind::NaN
9040 }
9041}
9042#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9043pub struct True(pub(crate) super::tree::CstNodeId);
9044impl TerminalHandle for True {
9045 fn node_id(&self) -> CstNodeId {
9046 self.0
9047 }
9048 fn kind(&self) -> TerminalKind {
9049 TerminalKind::True
9050 }
9051}
9052#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9053pub struct False(pub(crate) super::tree::CstNodeId);
9054impl TerminalHandle for False {
9055 fn node_id(&self) -> CstNodeId {
9056 self.0
9057 }
9058 fn kind(&self) -> TerminalKind {
9059 TerminalKind::False
9060 }
9061}
9062#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9063pub struct Null(pub(crate) super::tree::CstNodeId);
9064impl TerminalHandle for Null {
9065 fn node_id(&self) -> CstNodeId {
9066 self.0
9067 }
9068 fn kind(&self) -> TerminalKind {
9069 TerminalKind::Null
9070 }
9071}
9072#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9073pub struct Hole(pub(crate) super::tree::CstNodeId);
9074impl TerminalHandle for Hole {
9075 fn node_id(&self) -> CstNodeId {
9076 self.0
9077 }
9078 fn kind(&self) -> TerminalKind {
9079 TerminalKind::Hole
9080 }
9081}
9082#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9083pub struct Str(pub(crate) super::tree::CstNodeId);
9084impl TerminalHandle for Str {
9085 fn node_id(&self) -> CstNodeId {
9086 self.0
9087 }
9088 fn kind(&self) -> TerminalKind {
9089 TerminalKind::Str
9090 }
9091}
9092#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9093pub struct LitStr(pub(crate) super::tree::CstNodeId);
9094impl TerminalHandle for LitStr {
9095 fn node_id(&self) -> CstNodeId {
9096 self.0
9097 }
9098 fn kind(&self) -> TerminalKind {
9099 TerminalKind::LitStr
9100 }
9101}
9102#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9103pub struct Text(pub(crate) super::tree::CstNodeId);
9104impl TerminalHandle for Text {
9105 fn node_id(&self) -> CstNodeId {
9106 self.0
9107 }
9108 fn kind(&self) -> TerminalKind {
9109 TerminalKind::Text
9110 }
9111}
9112#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9113pub struct InlineCode1(pub(crate) super::tree::CstNodeId);
9114impl TerminalHandle for InlineCode1 {
9115 fn node_id(&self) -> CstNodeId {
9116 self.0
9117 }
9118 fn kind(&self) -> TerminalKind {
9119 TerminalKind::InlineCode1
9120 }
9121}
9122#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9123pub struct LitStr3Start(pub(crate) super::tree::CstNodeId);
9124impl TerminalHandle for LitStr3Start {
9125 fn node_id(&self) -> CstNodeId {
9126 self.0
9127 }
9128 fn kind(&self) -> TerminalKind {
9129 TerminalKind::LitStr3Start
9130 }
9131}
9132#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9133pub struct LitStr2Start(pub(crate) super::tree::CstNodeId);
9134impl TerminalHandle for LitStr2Start {
9135 fn node_id(&self) -> CstNodeId {
9136 self.0
9137 }
9138 fn kind(&self) -> TerminalKind {
9139 TerminalKind::LitStr2Start
9140 }
9141}
9142#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9143pub struct LitStr1Start(pub(crate) super::tree::CstNodeId);
9144impl TerminalHandle for LitStr1Start {
9145 fn node_id(&self) -> CstNodeId {
9146 self.0
9147 }
9148 fn kind(&self) -> TerminalKind {
9149 TerminalKind::LitStr1Start
9150 }
9151}
9152#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9153pub struct DelimCodeStart3(pub(crate) super::tree::CstNodeId);
9154impl TerminalHandle for DelimCodeStart3 {
9155 fn node_id(&self) -> CstNodeId {
9156 self.0
9157 }
9158 fn kind(&self) -> TerminalKind {
9159 TerminalKind::DelimCodeStart3
9160 }
9161}
9162#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9163pub struct DelimCodeStart2(pub(crate) super::tree::CstNodeId);
9164impl TerminalHandle for DelimCodeStart2 {
9165 fn node_id(&self) -> CstNodeId {
9166 self.0
9167 }
9168 fn kind(&self) -> TerminalKind {
9169 TerminalKind::DelimCodeStart2
9170 }
9171}
9172#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9173pub struct DelimCodeStart1(pub(crate) super::tree::CstNodeId);
9174impl TerminalHandle for DelimCodeStart1 {
9175 fn node_id(&self) -> CstNodeId {
9176 self.0
9177 }
9178 fn kind(&self) -> TerminalKind {
9179 TerminalKind::DelimCodeStart1
9180 }
9181}
9182#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9183pub struct CodeBlockStart3(pub(crate) super::tree::CstNodeId);
9184impl TerminalHandle for CodeBlockStart3 {
9185 fn node_id(&self) -> CstNodeId {
9186 self.0
9187 }
9188 fn kind(&self) -> TerminalKind {
9189 TerminalKind::CodeBlockStart3
9190 }
9191}
9192#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9193pub struct CodeBlockStart4(pub(crate) super::tree::CstNodeId);
9194impl TerminalHandle for CodeBlockStart4 {
9195 fn node_id(&self) -> CstNodeId {
9196 self.0
9197 }
9198 fn kind(&self) -> TerminalKind {
9199 TerminalKind::CodeBlockStart4
9200 }
9201}
9202#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9203pub struct CodeBlockStart5(pub(crate) super::tree::CstNodeId);
9204impl TerminalHandle for CodeBlockStart5 {
9205 fn node_id(&self) -> CstNodeId {
9206 self.0
9207 }
9208 fn kind(&self) -> TerminalKind {
9209 TerminalKind::CodeBlockStart5
9210 }
9211}
9212#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9213pub struct CodeBlockStart6(pub(crate) super::tree::CstNodeId);
9214impl TerminalHandle for CodeBlockStart6 {
9215 fn node_id(&self) -> CstNodeId {
9216 self.0
9217 }
9218 fn kind(&self) -> TerminalKind {
9219 TerminalKind::CodeBlockStart6
9220 }
9221}
9222#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9223pub struct CodeBlockEnd3(pub(crate) super::tree::CstNodeId);
9224impl TerminalHandle for CodeBlockEnd3 {
9225 fn node_id(&self) -> CstNodeId {
9226 self.0
9227 }
9228 fn kind(&self) -> TerminalKind {
9229 TerminalKind::CodeBlockEnd3
9230 }
9231}
9232#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9233pub struct Backtick2(pub(crate) super::tree::CstNodeId);
9234impl TerminalHandle for Backtick2 {
9235 fn node_id(&self) -> CstNodeId {
9236 self.0
9237 }
9238 fn kind(&self) -> TerminalKind {
9239 TerminalKind::Backtick2
9240 }
9241}
9242#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9243pub struct CodeBlockEnd4(pub(crate) super::tree::CstNodeId);
9244impl TerminalHandle for CodeBlockEnd4 {
9245 fn node_id(&self) -> CstNodeId {
9246 self.0
9247 }
9248 fn kind(&self) -> TerminalKind {
9249 TerminalKind::CodeBlockEnd4
9250 }
9251}
9252#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9253pub struct Backtick3(pub(crate) super::tree::CstNodeId);
9254impl TerminalHandle for Backtick3 {
9255 fn node_id(&self) -> CstNodeId {
9256 self.0
9257 }
9258 fn kind(&self) -> TerminalKind {
9259 TerminalKind::Backtick3
9260 }
9261}
9262#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9263pub struct CodeBlockEnd5(pub(crate) super::tree::CstNodeId);
9264impl TerminalHandle for CodeBlockEnd5 {
9265 fn node_id(&self) -> CstNodeId {
9266 self.0
9267 }
9268 fn kind(&self) -> TerminalKind {
9269 TerminalKind::CodeBlockEnd5
9270 }
9271}
9272#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9273pub struct Backtick4(pub(crate) super::tree::CstNodeId);
9274impl TerminalHandle for Backtick4 {
9275 fn node_id(&self) -> CstNodeId {
9276 self.0
9277 }
9278 fn kind(&self) -> TerminalKind {
9279 TerminalKind::Backtick4
9280 }
9281}
9282#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9283pub struct CodeBlockEnd6(pub(crate) super::tree::CstNodeId);
9284impl TerminalHandle for CodeBlockEnd6 {
9285 fn node_id(&self) -> CstNodeId {
9286 self.0
9287 }
9288 fn kind(&self) -> TerminalKind {
9289 TerminalKind::CodeBlockEnd6
9290 }
9291}
9292#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9293pub struct Backtick5(pub(crate) super::tree::CstNodeId);
9294impl TerminalHandle for Backtick5 {
9295 fn node_id(&self) -> CstNodeId {
9296 self.0
9297 }
9298 fn kind(&self) -> TerminalKind {
9299 TerminalKind::Backtick5
9300 }
9301}
9302#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9303pub struct NoBacktick(pub(crate) super::tree::CstNodeId);
9304impl TerminalHandle for NoBacktick {
9305 fn node_id(&self) -> CstNodeId {
9306 self.0
9307 }
9308 fn kind(&self) -> TerminalKind {
9309 TerminalKind::NoBacktick
9310 }
9311}
9312#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9313pub struct LitStr3End(pub(crate) super::tree::CstNodeId);
9314impl TerminalHandle for LitStr3End {
9315 fn node_id(&self) -> CstNodeId {
9316 self.0
9317 }
9318 fn kind(&self) -> TerminalKind {
9319 TerminalKind::LitStr3End
9320 }
9321}
9322#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9323pub struct LitStr2End(pub(crate) super::tree::CstNodeId);
9324impl TerminalHandle for LitStr2End {
9325 fn node_id(&self) -> CstNodeId {
9326 self.0
9327 }
9328 fn kind(&self) -> TerminalKind {
9329 TerminalKind::LitStr2End
9330 }
9331}
9332#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9333pub struct LitStr1End(pub(crate) super::tree::CstNodeId);
9334impl TerminalHandle for LitStr1End {
9335 fn node_id(&self) -> CstNodeId {
9336 self.0
9337 }
9338 fn kind(&self) -> TerminalKind {
9339 TerminalKind::LitStr1End
9340 }
9341}
9342#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9343pub struct SQuote(pub(crate) super::tree::CstNodeId);
9344impl TerminalHandle for SQuote {
9345 fn node_id(&self) -> CstNodeId {
9346 self.0
9347 }
9348 fn kind(&self) -> TerminalKind {
9349 TerminalKind::SQuote
9350 }
9351}
9352#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9353pub struct NoSQuote(pub(crate) super::tree::CstNodeId);
9354impl TerminalHandle for NoSQuote {
9355 fn node_id(&self) -> CstNodeId {
9356 self.0
9357 }
9358 fn kind(&self) -> TerminalKind {
9359 TerminalKind::NoSQuote
9360 }
9361}
9362#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9363pub struct DelimCodeEnd3(pub(crate) super::tree::CstNodeId);
9364impl TerminalHandle for DelimCodeEnd3 {
9365 fn node_id(&self) -> CstNodeId {
9366 self.0
9367 }
9368 fn kind(&self) -> TerminalKind {
9369 TerminalKind::DelimCodeEnd3
9370 }
9371}
9372#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9373pub struct DelimCodeEnd2(pub(crate) super::tree::CstNodeId);
9374impl TerminalHandle for DelimCodeEnd2 {
9375 fn node_id(&self) -> CstNodeId {
9376 self.0
9377 }
9378 fn kind(&self) -> TerminalKind {
9379 TerminalKind::DelimCodeEnd2
9380 }
9381}
9382#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9383pub struct DelimCodeEnd1(pub(crate) super::tree::CstNodeId);
9384impl TerminalHandle for DelimCodeEnd1 {
9385 fn node_id(&self) -> CstNodeId {
9386 self.0
9387 }
9388 fn kind(&self) -> TerminalKind {
9389 TerminalKind::DelimCodeEnd1
9390 }
9391}
9392#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9393pub struct BacktickDelim(pub(crate) super::tree::CstNodeId);
9394impl TerminalHandle for BacktickDelim {
9395 fn node_id(&self) -> CstNodeId {
9396 self.0
9397 }
9398 fn kind(&self) -> TerminalKind {
9399 TerminalKind::BacktickDelim
9400 }
9401}
9402#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9403pub struct GrammarNewline(pub(crate) super::tree::CstNodeId);
9404impl TerminalHandle for GrammarNewline {
9405 fn node_id(&self) -> CstNodeId {
9406 self.0
9407 }
9408 fn kind(&self) -> TerminalKind {
9409 TerminalKind::GrammarNewline
9410 }
9411}
9412#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9413pub struct Ws(pub(crate) super::tree::CstNodeId);
9414impl TerminalHandle for Ws {
9415 fn node_id(&self) -> CstNodeId {
9416 self.0
9417 }
9418 fn kind(&self) -> TerminalKind {
9419 TerminalKind::Ws
9420 }
9421}
9422#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9423pub struct At(pub(crate) super::tree::CstNodeId);
9424impl TerminalHandle for At {
9425 fn node_id(&self) -> CstNodeId {
9426 self.0
9427 }
9428 fn kind(&self) -> TerminalKind {
9429 TerminalKind::At
9430 }
9431}
9432#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9433pub struct Dollar(pub(crate) super::tree::CstNodeId);
9434impl TerminalHandle for Dollar {
9435 fn node_id(&self) -> CstNodeId {
9436 self.0
9437 }
9438 fn kind(&self) -> TerminalKind {
9439 TerminalKind::Dollar
9440 }
9441}
9442#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9443pub struct Dot(pub(crate) super::tree::CstNodeId);
9444impl TerminalHandle for Dot {
9445 fn node_id(&self) -> CstNodeId {
9446 self.0
9447 }
9448 fn kind(&self) -> TerminalKind {
9449 TerminalKind::Dot
9450 }
9451}
9452#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9453pub struct LBrace(pub(crate) super::tree::CstNodeId);
9454impl TerminalHandle for LBrace {
9455 fn node_id(&self) -> CstNodeId {
9456 self.0
9457 }
9458 fn kind(&self) -> TerminalKind {
9459 TerminalKind::LBrace
9460 }
9461}
9462#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9463pub struct RBrace(pub(crate) super::tree::CstNodeId);
9464impl TerminalHandle for RBrace {
9465 fn node_id(&self) -> CstNodeId {
9466 self.0
9467 }
9468 fn kind(&self) -> TerminalKind {
9469 TerminalKind::RBrace
9470 }
9471}
9472#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9473pub struct LBracket(pub(crate) super::tree::CstNodeId);
9474impl TerminalHandle for LBracket {
9475 fn node_id(&self) -> CstNodeId {
9476 self.0
9477 }
9478 fn kind(&self) -> TerminalKind {
9479 TerminalKind::LBracket
9480 }
9481}
9482#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9483pub struct RBracket(pub(crate) super::tree::CstNodeId);
9484impl TerminalHandle for RBracket {
9485 fn node_id(&self) -> CstNodeId {
9486 self.0
9487 }
9488 fn kind(&self) -> TerminalKind {
9489 TerminalKind::RBracket
9490 }
9491}
9492#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9493pub struct LParen(pub(crate) super::tree::CstNodeId);
9494impl TerminalHandle for LParen {
9495 fn node_id(&self) -> CstNodeId {
9496 self.0
9497 }
9498 fn kind(&self) -> TerminalKind {
9499 TerminalKind::LParen
9500 }
9501}
9502#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9503pub struct RParen(pub(crate) super::tree::CstNodeId);
9504impl TerminalHandle for RParen {
9505 fn node_id(&self) -> CstNodeId {
9506 self.0
9507 }
9508 fn kind(&self) -> TerminalKind {
9509 TerminalKind::RParen
9510 }
9511}
9512#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9513pub struct NewlineBind(pub(crate) super::tree::CstNodeId);
9514impl TerminalHandle for NewlineBind {
9515 fn node_id(&self) -> CstNodeId {
9516 self.0
9517 }
9518 fn kind(&self) -> TerminalKind {
9519 TerminalKind::NewlineBind
9520 }
9521}
9522#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9523pub struct Bind(pub(crate) super::tree::CstNodeId);
9524impl TerminalHandle for Bind {
9525 fn node_id(&self) -> CstNodeId {
9526 self.0
9527 }
9528 fn kind(&self) -> TerminalKind {
9529 TerminalKind::Bind
9530 }
9531}
9532#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9533pub struct Comma(pub(crate) super::tree::CstNodeId);
9534impl TerminalHandle for Comma {
9535 fn node_id(&self) -> CstNodeId {
9536 self.0
9537 }
9538 fn kind(&self) -> TerminalKind {
9539 TerminalKind::Comma
9540 }
9541}
9542#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9543pub struct Esc(pub(crate) super::tree::CstNodeId);
9544impl TerminalHandle for Esc {
9545 fn node_id(&self) -> CstNodeId {
9546 self.0
9547 }
9548 fn kind(&self) -> TerminalKind {
9549 TerminalKind::Esc
9550 }
9551}
9552#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9553pub struct NewlineTextStart(pub(crate) super::tree::CstNodeId);
9554impl TerminalHandle for NewlineTextStart {
9555 fn node_id(&self) -> CstNodeId {
9556 self.0
9557 }
9558 fn kind(&self) -> TerminalKind {
9559 TerminalKind::NewlineTextStart
9560 }
9561}
9562#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9563pub struct TextStart(pub(crate) super::tree::CstNodeId);
9564impl TerminalHandle for TextStart {
9565 fn node_id(&self) -> CstNodeId {
9566 self.0
9567 }
9568 fn kind(&self) -> TerminalKind {
9569 TerminalKind::TextStart
9570 }
9571}
9572#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
9573pub struct Ident(pub(crate) super::tree::CstNodeId);
9574impl TerminalHandle for Ident {
9575 fn node_id(&self) -> CstNodeId {
9576 self.0
9577 }
9578 fn kind(&self) -> TerminalKind {
9579 TerminalKind::Ident
9580 }
9581}