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