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