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_2(
98 &mut self,
99 handle: Backtick2Handle,
100 view: Backtick2View,
101 tree: &F,
102 ) -> Result<(), Self::Error> {
103 self.visit_backtick_2_super(handle, view, tree)
104 }
105 fn visit_backtick_3(
106 &mut self,
107 handle: Backtick3Handle,
108 view: Backtick3View,
109 tree: &F,
110 ) -> Result<(), Self::Error> {
111 self.visit_backtick_3_super(handle, view, tree)
112 }
113 fn visit_backtick_4(
114 &mut self,
115 handle: Backtick4Handle,
116 view: Backtick4View,
117 tree: &F,
118 ) -> Result<(), Self::Error> {
119 self.visit_backtick_4_super(handle, view, tree)
120 }
121 fn visit_backtick_5(
122 &mut self,
123 handle: Backtick5Handle,
124 view: Backtick5View,
125 tree: &F,
126 ) -> Result<(), Self::Error> {
127 self.visit_backtick_5_super(handle, view, tree)
128 }
129 fn visit_backtick_delim(
130 &mut self,
131 handle: BacktickDelimHandle,
132 view: BacktickDelimView,
133 tree: &F,
134 ) -> Result<(), Self::Error> {
135 self.visit_backtick_delim_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_block_body(
170 &mut self,
171 handle: BlockBodyHandle,
172 view: BlockBodyView,
173 tree: &F,
174 ) -> Result<(), Self::Error> {
175 self.visit_block_body_super(handle, view, tree)
176 }
177 fn visit_boolean(
178 &mut self,
179 handle: BooleanHandle,
180 view: BooleanView,
181 tree: &F,
182 ) -> Result<(), Self::Error> {
183 self.visit_boolean_super(handle, view, tree)
184 }
185 fn visit_code_block(
186 &mut self,
187 handle: CodeBlockHandle,
188 view: CodeBlockView,
189 tree: &F,
190 ) -> Result<(), Self::Error> {
191 self.visit_code_block_super(handle, view, tree)
192 }
193 fn visit_code_block_3(
194 &mut self,
195 handle: CodeBlock3Handle,
196 view: CodeBlock3View,
197 tree: &F,
198 ) -> Result<(), Self::Error> {
199 self.visit_code_block_3_super(handle, view, tree)
200 }
201 fn visit_code_block_3_list(
202 &mut self,
203 handle: CodeBlock3ListHandle,
204 view: CodeBlock3ListView,
205 tree: &F,
206 ) -> Result<(), Self::Error> {
207 self.visit_code_block_3_list_super(handle, view, tree)
208 }
209 fn visit_code_block_3_list_group(
210 &mut self,
211 handle: CodeBlock3ListGroupHandle,
212 view: CodeBlock3ListGroupView,
213 tree: &F,
214 ) -> Result<(), Self::Error> {
215 self.visit_code_block_3_list_group_super(handle, view, tree)
216 }
217 fn visit_code_block_4(
218 &mut self,
219 handle: CodeBlock4Handle,
220 view: CodeBlock4View,
221 tree: &F,
222 ) -> Result<(), Self::Error> {
223 self.visit_code_block_4_super(handle, view, tree)
224 }
225 fn visit_code_block_4_list(
226 &mut self,
227 handle: CodeBlock4ListHandle,
228 view: CodeBlock4ListView,
229 tree: &F,
230 ) -> Result<(), Self::Error> {
231 self.visit_code_block_4_list_super(handle, view, tree)
232 }
233 fn visit_code_block_4_list_group(
234 &mut self,
235 handle: CodeBlock4ListGroupHandle,
236 view: CodeBlock4ListGroupView,
237 tree: &F,
238 ) -> Result<(), Self::Error> {
239 self.visit_code_block_4_list_group_super(handle, view, tree)
240 }
241 fn visit_code_block_5(
242 &mut self,
243 handle: CodeBlock5Handle,
244 view: CodeBlock5View,
245 tree: &F,
246 ) -> Result<(), Self::Error> {
247 self.visit_code_block_5_super(handle, view, tree)
248 }
249 fn visit_code_block_5_list(
250 &mut self,
251 handle: CodeBlock5ListHandle,
252 view: CodeBlock5ListView,
253 tree: &F,
254 ) -> Result<(), Self::Error> {
255 self.visit_code_block_5_list_super(handle, view, tree)
256 }
257 fn visit_code_block_5_list_group(
258 &mut self,
259 handle: CodeBlock5ListGroupHandle,
260 view: CodeBlock5ListGroupView,
261 tree: &F,
262 ) -> Result<(), Self::Error> {
263 self.visit_code_block_5_list_group_super(handle, view, tree)
264 }
265 fn visit_code_block_6(
266 &mut self,
267 handle: CodeBlock6Handle,
268 view: CodeBlock6View,
269 tree: &F,
270 ) -> Result<(), Self::Error> {
271 self.visit_code_block_6_super(handle, view, tree)
272 }
273 fn visit_code_block_6_list(
274 &mut self,
275 handle: CodeBlock6ListHandle,
276 view: CodeBlock6ListView,
277 tree: &F,
278 ) -> Result<(), Self::Error> {
279 self.visit_code_block_6_list_super(handle, view, tree)
280 }
281 fn visit_code_block_6_list_group(
282 &mut self,
283 handle: CodeBlock6ListGroupHandle,
284 view: CodeBlock6ListGroupView,
285 tree: &F,
286 ) -> Result<(), Self::Error> {
287 self.visit_code_block_6_list_group_super(handle, view, tree)
288 }
289 fn visit_code_block_end_3(
290 &mut self,
291 handle: CodeBlockEnd3Handle,
292 view: CodeBlockEnd3View,
293 tree: &F,
294 ) -> Result<(), Self::Error> {
295 self.visit_code_block_end_3_super(handle, view, tree)
296 }
297 fn visit_code_block_end_4(
298 &mut self,
299 handle: CodeBlockEnd4Handle,
300 view: CodeBlockEnd4View,
301 tree: &F,
302 ) -> Result<(), Self::Error> {
303 self.visit_code_block_end_4_super(handle, view, tree)
304 }
305 fn visit_code_block_end_5(
306 &mut self,
307 handle: CodeBlockEnd5Handle,
308 view: CodeBlockEnd5View,
309 tree: &F,
310 ) -> Result<(), Self::Error> {
311 self.visit_code_block_end_5_super(handle, view, tree)
312 }
313 fn visit_code_block_end_6(
314 &mut self,
315 handle: CodeBlockEnd6Handle,
316 view: CodeBlockEnd6View,
317 tree: &F,
318 ) -> Result<(), Self::Error> {
319 self.visit_code_block_end_6_super(handle, view, tree)
320 }
321 fn visit_code_block_start_3(
322 &mut self,
323 handle: CodeBlockStart3Handle,
324 view: CodeBlockStart3View,
325 tree: &F,
326 ) -> Result<(), Self::Error> {
327 self.visit_code_block_start_3_super(handle, view, tree)
328 }
329 fn visit_code_block_start_4(
330 &mut self,
331 handle: CodeBlockStart4Handle,
332 view: CodeBlockStart4View,
333 tree: &F,
334 ) -> Result<(), Self::Error> {
335 self.visit_code_block_start_4_super(handle, view, tree)
336 }
337 fn visit_code_block_start_5(
338 &mut self,
339 handle: CodeBlockStart5Handle,
340 view: CodeBlockStart5View,
341 tree: &F,
342 ) -> Result<(), Self::Error> {
343 self.visit_code_block_start_5_super(handle, view, tree)
344 }
345 fn visit_code_block_start_6(
346 &mut self,
347 handle: CodeBlockStart6Handle,
348 view: CodeBlockStart6View,
349 tree: &F,
350 ) -> Result<(), Self::Error> {
351 self.visit_code_block_start_6_super(handle, view, tree)
352 }
353 fn visit_comma(
354 &mut self,
355 handle: CommaHandle,
356 view: CommaView,
357 tree: &F,
358 ) -> Result<(), Self::Error> {
359 self.visit_comma_super(handle, view, tree)
360 }
361 fn visit_continue(
362 &mut self,
363 handle: ContinueHandle,
364 view: ContinueView,
365 tree: &F,
366 ) -> Result<(), Self::Error> {
367 self.visit_continue_super(handle, view, tree)
368 }
369 fn visit_delim_code(
370 &mut self,
371 handle: DelimCodeHandle,
372 view: DelimCodeView,
373 tree: &F,
374 ) -> Result<(), Self::Error> {
375 self.visit_delim_code_super(handle, view, tree)
376 }
377 fn visit_delim_code_1(
378 &mut self,
379 handle: DelimCode1Handle,
380 view: DelimCode1View,
381 tree: &F,
382 ) -> Result<(), Self::Error> {
383 self.visit_delim_code_1_super(handle, view, tree)
384 }
385 fn visit_delim_code_1_list(
386 &mut self,
387 handle: DelimCode1ListHandle,
388 view: DelimCode1ListView,
389 tree: &F,
390 ) -> Result<(), Self::Error> {
391 self.visit_delim_code_1_list_super(handle, view, tree)
392 }
393 fn visit_delim_code_1_list_group(
394 &mut self,
395 handle: DelimCode1ListGroupHandle,
396 view: DelimCode1ListGroupView,
397 tree: &F,
398 ) -> Result<(), Self::Error> {
399 self.visit_delim_code_1_list_group_super(handle, view, tree)
400 }
401 fn visit_delim_code_2(
402 &mut self,
403 handle: DelimCode2Handle,
404 view: DelimCode2View,
405 tree: &F,
406 ) -> Result<(), Self::Error> {
407 self.visit_delim_code_2_super(handle, view, tree)
408 }
409 fn visit_delim_code_2_list(
410 &mut self,
411 handle: DelimCode2ListHandle,
412 view: DelimCode2ListView,
413 tree: &F,
414 ) -> Result<(), Self::Error> {
415 self.visit_delim_code_2_list_super(handle, view, tree)
416 }
417 fn visit_delim_code_2_list_group(
418 &mut self,
419 handle: DelimCode2ListGroupHandle,
420 view: DelimCode2ListGroupView,
421 tree: &F,
422 ) -> Result<(), Self::Error> {
423 self.visit_delim_code_2_list_group_super(handle, view, tree)
424 }
425 fn visit_delim_code_3(
426 &mut self,
427 handle: DelimCode3Handle,
428 view: DelimCode3View,
429 tree: &F,
430 ) -> Result<(), Self::Error> {
431 self.visit_delim_code_3_super(handle, view, tree)
432 }
433 fn visit_delim_code_3_list(
434 &mut self,
435 handle: DelimCode3ListHandle,
436 view: DelimCode3ListView,
437 tree: &F,
438 ) -> Result<(), Self::Error> {
439 self.visit_delim_code_3_list_super(handle, view, tree)
440 }
441 fn visit_delim_code_3_list_group(
442 &mut self,
443 handle: DelimCode3ListGroupHandle,
444 view: DelimCode3ListGroupView,
445 tree: &F,
446 ) -> Result<(), Self::Error> {
447 self.visit_delim_code_3_list_group_super(handle, view, tree)
448 }
449 fn visit_delim_code_end_1(
450 &mut self,
451 handle: DelimCodeEnd1Handle,
452 view: DelimCodeEnd1View,
453 tree: &F,
454 ) -> Result<(), Self::Error> {
455 self.visit_delim_code_end_1_super(handle, view, tree)
456 }
457 fn visit_delim_code_end_2(
458 &mut self,
459 handle: DelimCodeEnd2Handle,
460 view: DelimCodeEnd2View,
461 tree: &F,
462 ) -> Result<(), Self::Error> {
463 self.visit_delim_code_end_2_super(handle, view, tree)
464 }
465 fn visit_delim_code_end_3(
466 &mut self,
467 handle: DelimCodeEnd3Handle,
468 view: DelimCodeEnd3View,
469 tree: &F,
470 ) -> Result<(), Self::Error> {
471 self.visit_delim_code_end_3_super(handle, view, tree)
472 }
473 fn visit_delim_code_start_1(
474 &mut self,
475 handle: DelimCodeStart1Handle,
476 view: DelimCodeStart1View,
477 tree: &F,
478 ) -> Result<(), Self::Error> {
479 self.visit_delim_code_start_1_super(handle, view, tree)
480 }
481 fn visit_delim_code_start_2(
482 &mut self,
483 handle: DelimCodeStart2Handle,
484 view: DelimCodeStart2View,
485 tree: &F,
486 ) -> Result<(), Self::Error> {
487 self.visit_delim_code_start_2_super(handle, view, tree)
488 }
489 fn visit_delim_code_start_3(
490 &mut self,
491 handle: DelimCodeStart3Handle,
492 view: DelimCodeStart3View,
493 tree: &F,
494 ) -> Result<(), Self::Error> {
495 self.visit_delim_code_start_3_super(handle, view, tree)
496 }
497 fn visit_dot(&mut self, handle: DotHandle, view: DotView, tree: &F) -> Result<(), Self::Error> {
498 self.visit_dot_super(handle, view, tree)
499 }
500 fn visit_dot_key(
501 &mut self,
502 handle: DotKeyHandle,
503 view: DotKeyView,
504 tree: &F,
505 ) -> Result<(), Self::Error> {
506 self.visit_dot_key_super(handle, view, tree)
507 }
508 fn visit_end(&mut self, handle: EndHandle, view: EndView, tree: &F) -> Result<(), Self::Error> {
509 self.visit_end_super(handle, view, tree)
510 }
511 fn visit_eure(
512 &mut self,
513 handle: EureHandle,
514 view: EureView,
515 tree: &F,
516 ) -> Result<(), Self::Error> {
517 self.visit_eure_super(handle, view, tree)
518 }
519 fn visit_eure_bindings(
520 &mut self,
521 handle: EureBindingsHandle,
522 view: EureBindingsView,
523 tree: &F,
524 ) -> Result<(), Self::Error> {
525 self.visit_eure_bindings_super(handle, view, tree)
526 }
527 fn visit_eure_sections(
528 &mut self,
529 handle: EureSectionsHandle,
530 view: EureSectionsView,
531 tree: &F,
532 ) -> Result<(), Self::Error> {
533 self.visit_eure_sections_super(handle, view, tree)
534 }
535 fn visit_eure_opt(
536 &mut self,
537 handle: EureOptHandle,
538 view: TopLevelBindingHandle,
539 tree: &F,
540 ) -> Result<(), Self::Error> {
541 self.visit_eure_opt_super(handle, view, tree)
542 }
543 fn visit_ext(&mut self, handle: ExtHandle, view: ExtView, tree: &F) -> Result<(), Self::Error> {
544 self.visit_ext_super(handle, view, tree)
545 }
546 fn visit_extension_name_space(
547 &mut self,
548 handle: ExtensionNameSpaceHandle,
549 view: ExtensionNameSpaceView,
550 tree: &F,
551 ) -> Result<(), Self::Error> {
552 self.visit_extension_name_space_super(handle, view, tree)
553 }
554 fn visit_false(
555 &mut self,
556 handle: FalseHandle,
557 view: FalseView,
558 tree: &F,
559 ) -> Result<(), Self::Error> {
560 self.visit_false_super(handle, view, tree)
561 }
562 fn visit_first_key(
563 &mut self,
564 handle: FirstKeyHandle,
565 view: FirstKeyView,
566 tree: &F,
567 ) -> Result<(), Self::Error> {
568 self.visit_first_key_super(handle, view, tree)
569 }
570 fn visit_flat_body(
571 &mut self,
572 handle: FlatBodyHandle,
573 view: FlatBodyView,
574 tree: &F,
575 ) -> Result<(), Self::Error> {
576 self.visit_flat_body_super(handle, view, tree)
577 }
578 fn visit_flat_body_list(
579 &mut self,
580 handle: FlatBodyListHandle,
581 view: FlatBodyListView,
582 tree: &F,
583 ) -> Result<(), Self::Error> {
584 self.visit_flat_body_list_super(handle, view, tree)
585 }
586 fn visit_flat_root_binding(
587 &mut self,
588 handle: FlatRootBindingHandle,
589 view: FlatRootBindingView,
590 tree: &F,
591 ) -> Result<(), Self::Error> {
592 self.visit_flat_root_binding_super(handle, view, tree)
593 }
594 fn visit_float(
595 &mut self,
596 handle: FloatHandle,
597 view: FloatView,
598 tree: &F,
599 ) -> Result<(), Self::Error> {
600 self.visit_float_super(handle, view, tree)
601 }
602 fn visit_grammar_newline(
603 &mut self,
604 handle: GrammarNewlineHandle,
605 view: GrammarNewlineView,
606 tree: &F,
607 ) -> Result<(), Self::Error> {
608 self.visit_grammar_newline_super(handle, view, tree)
609 }
610 fn visit_hole(
611 &mut self,
612 handle: HoleHandle,
613 view: HoleView,
614 tree: &F,
615 ) -> Result<(), Self::Error> {
616 self.visit_hole_super(handle, view, tree)
617 }
618 fn visit_ident(
619 &mut self,
620 handle: IdentHandle,
621 view: IdentView,
622 tree: &F,
623 ) -> Result<(), Self::Error> {
624 self.visit_ident_super(handle, view, tree)
625 }
626 fn visit_inf(&mut self, handle: InfHandle, view: InfView, tree: &F) -> Result<(), Self::Error> {
627 self.visit_inf_super(handle, view, tree)
628 }
629 fn visit_inline_code(
630 &mut self,
631 handle: InlineCodeHandle,
632 view: InlineCodeView,
633 tree: &F,
634 ) -> Result<(), Self::Error> {
635 self.visit_inline_code_super(handle, view, tree)
636 }
637 fn visit_inline_code_1(
638 &mut self,
639 handle: InlineCode1Handle,
640 view: InlineCode1View,
641 tree: &F,
642 ) -> Result<(), Self::Error> {
643 self.visit_inline_code_1_super(handle, view, tree)
644 }
645 fn visit_integer(
646 &mut self,
647 handle: IntegerHandle,
648 view: IntegerView,
649 tree: &F,
650 ) -> Result<(), Self::Error> {
651 self.visit_integer_super(handle, view, tree)
652 }
653 fn visit_key(&mut self, handle: KeyHandle, view: KeyView, tree: &F) -> Result<(), Self::Error> {
654 self.visit_key_super(handle, view, tree)
655 }
656 fn visit_key_ident(
657 &mut self,
658 handle: KeyIdentHandle,
659 view: KeyIdentView,
660 tree: &F,
661 ) -> Result<(), Self::Error> {
662 self.visit_key_ident_super(handle, view, tree)
663 }
664 fn visit_key_tail(
665 &mut self,
666 handle: KeyTailHandle,
667 view: KeyTailView,
668 tree: &F,
669 ) -> Result<(), Self::Error> {
670 self.visit_key_tail_super(handle, view, tree)
671 }
672 fn visit_key_tuple(
673 &mut self,
674 handle: KeyTupleHandle,
675 view: KeyTupleView,
676 tree: &F,
677 ) -> Result<(), Self::Error> {
678 self.visit_key_tuple_super(handle, view, tree)
679 }
680 fn visit_key_tuple_elements(
681 &mut self,
682 handle: KeyTupleElementsHandle,
683 view: KeyTupleElementsView,
684 tree: &F,
685 ) -> Result<(), Self::Error> {
686 self.visit_key_tuple_elements_super(handle, view, tree)
687 }
688 fn visit_key_tuple_elements_opt(
689 &mut self,
690 handle: KeyTupleElementsOptHandle,
691 view: KeyTupleElementsTailHandle,
692 tree: &F,
693 ) -> Result<(), Self::Error> {
694 self.visit_key_tuple_elements_opt_super(handle, view, tree)
695 }
696 fn visit_key_tuple_elements_tail(
697 &mut self,
698 handle: KeyTupleElementsTailHandle,
699 view: KeyTupleElementsTailView,
700 tree: &F,
701 ) -> Result<(), Self::Error> {
702 self.visit_key_tuple_elements_tail_super(handle, view, tree)
703 }
704 fn visit_key_tuple_elements_tail_opt(
705 &mut self,
706 handle: KeyTupleElementsTailOptHandle,
707 view: KeyTupleElementsHandle,
708 tree: &F,
709 ) -> Result<(), Self::Error> {
710 self.visit_key_tuple_elements_tail_opt_super(handle, view, tree)
711 }
712 fn visit_key_tuple_opt(
713 &mut self,
714 handle: KeyTupleOptHandle,
715 view: KeyTupleElementsHandle,
716 tree: &F,
717 ) -> Result<(), Self::Error> {
718 self.visit_key_tuple_opt_super(handle, view, tree)
719 }
720 fn visit_key_value(
721 &mut self,
722 handle: KeyValueHandle,
723 view: KeyValueView,
724 tree: &F,
725 ) -> Result<(), Self::Error> {
726 self.visit_key_value_super(handle, view, tree)
727 }
728 fn visit_keys(
729 &mut self,
730 handle: KeysHandle,
731 view: KeysView,
732 tree: &F,
733 ) -> Result<(), Self::Error> {
734 self.visit_keys_super(handle, view, tree)
735 }
736 fn visit_keys_list(
737 &mut self,
738 handle: KeysListHandle,
739 view: KeysListView,
740 tree: &F,
741 ) -> Result<(), Self::Error> {
742 self.visit_keys_list_super(handle, view, tree)
743 }
744 fn visit_l_paren(
745 &mut self,
746 handle: LParenHandle,
747 view: LParenView,
748 tree: &F,
749 ) -> Result<(), Self::Error> {
750 self.visit_l_paren_super(handle, view, tree)
751 }
752 fn visit_lit_str(
753 &mut self,
754 handle: LitStrHandle,
755 view: LitStrView,
756 tree: &F,
757 ) -> Result<(), Self::Error> {
758 self.visit_lit_str_super(handle, view, tree)
759 }
760 fn visit_lit_str_1(
761 &mut self,
762 handle: LitStr1Handle,
763 view: LitStr1View,
764 tree: &F,
765 ) -> Result<(), Self::Error> {
766 self.visit_lit_str_1_super(handle, view, tree)
767 }
768 fn visit_lit_str_1_end(
769 &mut self,
770 handle: LitStr1EndHandle,
771 view: LitStr1EndView,
772 tree: &F,
773 ) -> Result<(), Self::Error> {
774 self.visit_lit_str_1_end_super(handle, view, tree)
775 }
776 fn visit_lit_str_1_list(
777 &mut self,
778 handle: LitStr1ListHandle,
779 view: LitStr1ListView,
780 tree: &F,
781 ) -> Result<(), Self::Error> {
782 self.visit_lit_str_1_list_super(handle, view, tree)
783 }
784 fn visit_lit_str_1_list_group(
785 &mut self,
786 handle: LitStr1ListGroupHandle,
787 view: LitStr1ListGroupView,
788 tree: &F,
789 ) -> Result<(), Self::Error> {
790 self.visit_lit_str_1_list_group_super(handle, view, tree)
791 }
792 fn visit_lit_str_1_start(
793 &mut self,
794 handle: LitStr1StartHandle,
795 view: LitStr1StartView,
796 tree: &F,
797 ) -> Result<(), Self::Error> {
798 self.visit_lit_str_1_start_super(handle, view, tree)
799 }
800 fn visit_lit_str_2(
801 &mut self,
802 handle: LitStr2Handle,
803 view: LitStr2View,
804 tree: &F,
805 ) -> Result<(), Self::Error> {
806 self.visit_lit_str_2_super(handle, view, tree)
807 }
808 fn visit_lit_str_2_end(
809 &mut self,
810 handle: LitStr2EndHandle,
811 view: LitStr2EndView,
812 tree: &F,
813 ) -> Result<(), Self::Error> {
814 self.visit_lit_str_2_end_super(handle, view, tree)
815 }
816 fn visit_lit_str_2_list(
817 &mut self,
818 handle: LitStr2ListHandle,
819 view: LitStr2ListView,
820 tree: &F,
821 ) -> Result<(), Self::Error> {
822 self.visit_lit_str_2_list_super(handle, view, tree)
823 }
824 fn visit_lit_str_2_list_group(
825 &mut self,
826 handle: LitStr2ListGroupHandle,
827 view: LitStr2ListGroupView,
828 tree: &F,
829 ) -> Result<(), Self::Error> {
830 self.visit_lit_str_2_list_group_super(handle, view, tree)
831 }
832 fn visit_lit_str_2_start(
833 &mut self,
834 handle: LitStr2StartHandle,
835 view: LitStr2StartView,
836 tree: &F,
837 ) -> Result<(), Self::Error> {
838 self.visit_lit_str_2_start_super(handle, view, tree)
839 }
840 fn visit_lit_str_3(
841 &mut self,
842 handle: LitStr3Handle,
843 view: LitStr3View,
844 tree: &F,
845 ) -> Result<(), Self::Error> {
846 self.visit_lit_str_3_super(handle, view, tree)
847 }
848 fn visit_lit_str_3_end(
849 &mut self,
850 handle: LitStr3EndHandle,
851 view: LitStr3EndView,
852 tree: &F,
853 ) -> Result<(), Self::Error> {
854 self.visit_lit_str_3_end_super(handle, view, tree)
855 }
856 fn visit_lit_str_3_list(
857 &mut self,
858 handle: LitStr3ListHandle,
859 view: LitStr3ListView,
860 tree: &F,
861 ) -> Result<(), Self::Error> {
862 self.visit_lit_str_3_list_super(handle, view, tree)
863 }
864 fn visit_lit_str_3_list_group(
865 &mut self,
866 handle: LitStr3ListGroupHandle,
867 view: LitStr3ListGroupView,
868 tree: &F,
869 ) -> Result<(), Self::Error> {
870 self.visit_lit_str_3_list_group_super(handle, view, tree)
871 }
872 fn visit_lit_str_3_start(
873 &mut self,
874 handle: LitStr3StartHandle,
875 view: LitStr3StartView,
876 tree: &F,
877 ) -> Result<(), Self::Error> {
878 self.visit_lit_str_3_start_super(handle, view, tree)
879 }
880 fn visit_map_bind(
881 &mut self,
882 handle: MapBindHandle,
883 view: MapBindView,
884 tree: &F,
885 ) -> Result<(), Self::Error> {
886 self.visit_map_bind_super(handle, view, tree)
887 }
888 fn visit_na_n(
889 &mut self,
890 handle: NaNHandle,
891 view: NaNView,
892 tree: &F,
893 ) -> Result<(), Self::Error> {
894 self.visit_na_n_super(handle, view, tree)
895 }
896 fn visit_newline_bind(
897 &mut self,
898 handle: NewlineBindHandle,
899 view: NewlineBindView,
900 tree: &F,
901 ) -> Result<(), Self::Error> {
902 self.visit_newline_bind_super(handle, view, tree)
903 }
904 fn visit_newline_head(
905 &mut self,
906 handle: NewlineHeadHandle,
907 view: NewlineHeadView,
908 tree: &F,
909 ) -> Result<(), Self::Error> {
910 self.visit_newline_head_super(handle, view, tree)
911 }
912 fn visit_newline_head_opt(
913 &mut self,
914 handle: NewlineHeadOptHandle,
915 view: FlatRootBindingHandle,
916 tree: &F,
917 ) -> Result<(), Self::Error> {
918 self.visit_newline_head_opt_super(handle, view, tree)
919 }
920 fn visit_newline_text_start(
921 &mut self,
922 handle: NewlineTextStartHandle,
923 view: NewlineTextStartView,
924 tree: &F,
925 ) -> Result<(), Self::Error> {
926 self.visit_newline_text_start_super(handle, view, tree)
927 }
928 fn visit_no_backtick(
929 &mut self,
930 handle: NoBacktickHandle,
931 view: NoBacktickView,
932 tree: &F,
933 ) -> Result<(), Self::Error> {
934 self.visit_no_backtick_super(handle, view, tree)
935 }
936 fn visit_no_s_quote(
937 &mut self,
938 handle: NoSQuoteHandle,
939 view: NoSQuoteView,
940 tree: &F,
941 ) -> Result<(), Self::Error> {
942 self.visit_no_s_quote_super(handle, view, tree)
943 }
944 fn visit_null(
945 &mut self,
946 handle: NullHandle,
947 view: NullView,
948 tree: &F,
949 ) -> Result<(), Self::Error> {
950 self.visit_null_super(handle, view, tree)
951 }
952 fn visit_number(
953 &mut self,
954 handle: NumberHandle,
955 view: NumberView,
956 tree: &F,
957 ) -> Result<(), Self::Error> {
958 self.visit_number_super(handle, view, tree)
959 }
960 fn visit_object(
961 &mut self,
962 handle: ObjectHandle,
963 view: ObjectView,
964 tree: &F,
965 ) -> Result<(), Self::Error> {
966 self.visit_object_super(handle, view, tree)
967 }
968 fn visit_object_list(
969 &mut self,
970 handle: ObjectListHandle,
971 view: ObjectListView,
972 tree: &F,
973 ) -> Result<(), Self::Error> {
974 self.visit_object_list_super(handle, view, tree)
975 }
976 fn visit_object_opt(
977 &mut self,
978 handle: ObjectOptHandle,
979 view: ObjectOptView,
980 tree: &F,
981 ) -> Result<(), Self::Error> {
982 self.visit_object_opt_super(handle, view, tree)
983 }
984 fn visit_object_opt_0(
985 &mut self,
986 handle: ObjectOpt0Handle,
987 view: CommaHandle,
988 tree: &F,
989 ) -> Result<(), Self::Error> {
990 self.visit_object_opt_0_super(handle, view, tree)
991 }
992 fn visit_object_opt_1(
993 &mut self,
994 handle: ObjectOpt1Handle,
995 view: CommaHandle,
996 tree: &F,
997 ) -> Result<(), Self::Error> {
998 self.visit_object_opt_1_super(handle, view, tree)
999 }
1000 fn visit_r_paren(
1001 &mut self,
1002 handle: RParenHandle,
1003 view: RParenView,
1004 tree: &F,
1005 ) -> Result<(), Self::Error> {
1006 self.visit_r_paren_super(handle, view, tree)
1007 }
1008 fn visit_root_binding(
1009 &mut self,
1010 handle: RootBindingHandle,
1011 view: RootBindingView,
1012 tree: &F,
1013 ) -> Result<(), Self::Error> {
1014 self.visit_root_binding_super(handle, view, tree)
1015 }
1016 fn visit_root_text_binding(
1017 &mut self,
1018 handle: RootTextBindingHandle,
1019 view: RootTextBindingView,
1020 tree: &F,
1021 ) -> Result<(), Self::Error> {
1022 self.visit_root_text_binding_super(handle, view, tree)
1023 }
1024 fn visit_root_text_binding_opt(
1025 &mut self,
1026 handle: RootTextBindingOptHandle,
1027 view: WsHandle,
1028 tree: &F,
1029 ) -> Result<(), Self::Error> {
1030 self.visit_root_text_binding_opt_super(handle, view, tree)
1031 }
1032 fn visit_root_text_binding_opt_0(
1033 &mut self,
1034 handle: RootTextBindingOpt0Handle,
1035 view: TextHandle,
1036 tree: &F,
1037 ) -> Result<(), Self::Error> {
1038 self.visit_root_text_binding_opt_0_super(handle, view, tree)
1039 }
1040 fn visit_root_text_binding_opt_1(
1041 &mut self,
1042 handle: RootTextBindingOpt1Handle,
1043 view: GrammarNewlineHandle,
1044 tree: &F,
1045 ) -> Result<(), Self::Error> {
1046 self.visit_root_text_binding_opt_1_super(handle, view, tree)
1047 }
1048 fn visit_root_value_binding(
1049 &mut self,
1050 handle: RootValueBindingHandle,
1051 view: RootValueBindingView,
1052 tree: &F,
1053 ) -> Result<(), Self::Error> {
1054 self.visit_root_value_binding_super(handle, view, tree)
1055 }
1056 fn visit_s_quote(
1057 &mut self,
1058 handle: SQuoteHandle,
1059 view: SQuoteView,
1060 tree: &F,
1061 ) -> Result<(), Self::Error> {
1062 self.visit_s_quote_super(handle, view, tree)
1063 }
1064 fn visit_section(
1065 &mut self,
1066 handle: SectionHandle,
1067 view: SectionView,
1068 tree: &F,
1069 ) -> Result<(), Self::Error> {
1070 self.visit_section_super(handle, view, tree)
1071 }
1072 fn visit_section_binding(
1073 &mut self,
1074 handle: SectionBindingHandle,
1075 view: SectionBindingView,
1076 tree: &F,
1077 ) -> Result<(), Self::Error> {
1078 self.visit_section_binding_super(handle, view, tree)
1079 }
1080 fn visit_section_body(
1081 &mut self,
1082 handle: SectionBodyHandle,
1083 view: SectionBodyView,
1084 tree: &F,
1085 ) -> Result<(), Self::Error> {
1086 self.visit_section_body_super(handle, view, tree)
1087 }
1088 fn visit_section_body_opt(
1089 &mut self,
1090 handle: SectionBodyOptHandle,
1091 view: FlatBodyHandle,
1092 tree: &F,
1093 ) -> Result<(), Self::Error> {
1094 self.visit_section_body_opt_super(handle, view, tree)
1095 }
1096 fn visit_section_head(
1097 &mut self,
1098 handle: SectionHeadHandle,
1099 view: SectionHeadView,
1100 tree: &F,
1101 ) -> Result<(), Self::Error> {
1102 self.visit_section_head_super(handle, view, tree)
1103 }
1104 fn visit_str(&mut self, handle: StrHandle, view: StrView, tree: &F) -> Result<(), Self::Error> {
1105 self.visit_str_super(handle, view, tree)
1106 }
1107 fn visit_string(
1108 &mut self,
1109 handle: StringHandle,
1110 view: StringView,
1111 tree: &F,
1112 ) -> Result<(), Self::Error> {
1113 self.visit_string_super(handle, view, tree)
1114 }
1115 fn visit_strings(
1116 &mut self,
1117 handle: StringsHandle,
1118 view: StringsView,
1119 tree: &F,
1120 ) -> Result<(), Self::Error> {
1121 self.visit_strings_super(handle, view, tree)
1122 }
1123 fn visit_strings_list(
1124 &mut self,
1125 handle: StringsListHandle,
1126 view: StringsListView,
1127 tree: &F,
1128 ) -> Result<(), Self::Error> {
1129 self.visit_strings_list_super(handle, view, tree)
1130 }
1131 fn visit_text(
1132 &mut self,
1133 handle: TextHandle,
1134 view: TextView,
1135 tree: &F,
1136 ) -> Result<(), Self::Error> {
1137 self.visit_text_super(handle, view, tree)
1138 }
1139 fn visit_text_binding(
1140 &mut self,
1141 handle: TextBindingHandle,
1142 view: TextBindingView,
1143 tree: &F,
1144 ) -> Result<(), Self::Error> {
1145 self.visit_text_binding_super(handle, view, tree)
1146 }
1147 fn visit_text_binding_opt(
1148 &mut self,
1149 handle: TextBindingOptHandle,
1150 view: WsHandle,
1151 tree: &F,
1152 ) -> Result<(), Self::Error> {
1153 self.visit_text_binding_opt_super(handle, view, tree)
1154 }
1155 fn visit_text_binding_opt_0(
1156 &mut self,
1157 handle: TextBindingOpt0Handle,
1158 view: TextHandle,
1159 tree: &F,
1160 ) -> Result<(), Self::Error> {
1161 self.visit_text_binding_opt_0_super(handle, view, tree)
1162 }
1163 fn visit_text_binding_opt_1(
1164 &mut self,
1165 handle: TextBindingOpt1Handle,
1166 view: GrammarNewlineHandle,
1167 tree: &F,
1168 ) -> Result<(), Self::Error> {
1169 self.visit_text_binding_opt_1_super(handle, view, tree)
1170 }
1171 fn visit_text_start(
1172 &mut self,
1173 handle: TextStartHandle,
1174 view: TextStartView,
1175 tree: &F,
1176 ) -> Result<(), Self::Error> {
1177 self.visit_text_start_super(handle, view, tree)
1178 }
1179 fn visit_top_level_binding(
1180 &mut self,
1181 handle: TopLevelBindingHandle,
1182 view: TopLevelBindingView,
1183 tree: &F,
1184 ) -> Result<(), Self::Error> {
1185 self.visit_top_level_binding_super(handle, view, tree)
1186 }
1187 fn visit_true(
1188 &mut self,
1189 handle: TrueHandle,
1190 view: TrueView,
1191 tree: &F,
1192 ) -> Result<(), Self::Error> {
1193 self.visit_true_super(handle, view, tree)
1194 }
1195 fn visit_tuple(
1196 &mut self,
1197 handle: TupleHandle,
1198 view: TupleView,
1199 tree: &F,
1200 ) -> Result<(), Self::Error> {
1201 self.visit_tuple_super(handle, view, tree)
1202 }
1203 fn visit_tuple_elements(
1204 &mut self,
1205 handle: TupleElementsHandle,
1206 view: TupleElementsView,
1207 tree: &F,
1208 ) -> Result<(), Self::Error> {
1209 self.visit_tuple_elements_super(handle, view, tree)
1210 }
1211 fn visit_tuple_elements_opt(
1212 &mut self,
1213 handle: TupleElementsOptHandle,
1214 view: TupleElementsTailHandle,
1215 tree: &F,
1216 ) -> Result<(), Self::Error> {
1217 self.visit_tuple_elements_opt_super(handle, view, tree)
1218 }
1219 fn visit_tuple_elements_tail(
1220 &mut self,
1221 handle: TupleElementsTailHandle,
1222 view: TupleElementsTailView,
1223 tree: &F,
1224 ) -> Result<(), Self::Error> {
1225 self.visit_tuple_elements_tail_super(handle, view, tree)
1226 }
1227 fn visit_tuple_elements_tail_opt(
1228 &mut self,
1229 handle: TupleElementsTailOptHandle,
1230 view: TupleElementsHandle,
1231 tree: &F,
1232 ) -> Result<(), Self::Error> {
1233 self.visit_tuple_elements_tail_opt_super(handle, view, tree)
1234 }
1235 fn visit_tuple_index(
1236 &mut self,
1237 handle: TupleIndexHandle,
1238 view: TupleIndexView,
1239 tree: &F,
1240 ) -> Result<(), Self::Error> {
1241 self.visit_tuple_index_super(handle, view, tree)
1242 }
1243 fn visit_tuple_opt(
1244 &mut self,
1245 handle: TupleOptHandle,
1246 view: TupleElementsHandle,
1247 tree: &F,
1248 ) -> Result<(), Self::Error> {
1249 self.visit_tuple_opt_super(handle, view, tree)
1250 }
1251 fn visit_value(
1252 &mut self,
1253 handle: ValueHandle,
1254 view: ValueView,
1255 tree: &F,
1256 ) -> Result<(), Self::Error> {
1257 self.visit_value_super(handle, view, tree)
1258 }
1259 fn visit_value_binding(
1260 &mut self,
1261 handle: ValueBindingHandle,
1262 view: ValueBindingView,
1263 tree: &F,
1264 ) -> Result<(), Self::Error> {
1265 self.visit_value_binding_super(handle, view, tree)
1266 }
1267 fn visit_ws(&mut self, handle: WsHandle, view: WsView, tree: &F) -> Result<(), Self::Error> {
1268 self.visit_ws_super(handle, view, tree)
1269 }
1270 fn visit_root(
1271 &mut self,
1272 handle: RootHandle,
1273 view: RootView,
1274 tree: &F,
1275 ) -> Result<(), Self::Error> {
1276 self.visit_root_super(handle, view, tree)
1277 }
1278 fn visit_new_line_terminal(
1279 &mut self,
1280 terminal: NewLine,
1281 data: TerminalData,
1282 tree: &F,
1283 ) -> Result<(), Self::Error> {
1284 self.visit_new_line_terminal_super(terminal, data, tree)
1285 }
1286 fn visit_whitespace_terminal(
1287 &mut self,
1288 terminal: Whitespace,
1289 data: TerminalData,
1290 tree: &F,
1291 ) -> Result<(), Self::Error> {
1292 self.visit_whitespace_terminal_super(terminal, data, tree)
1293 }
1294 fn visit_line_comment_terminal(
1295 &mut self,
1296 terminal: LineComment,
1297 data: TerminalData,
1298 tree: &F,
1299 ) -> Result<(), Self::Error> {
1300 self.visit_line_comment_terminal_super(terminal, data, tree)
1301 }
1302 fn visit_block_comment_terminal(
1303 &mut self,
1304 terminal: BlockComment,
1305 data: TerminalData,
1306 tree: &F,
1307 ) -> Result<(), Self::Error> {
1308 self.visit_block_comment_terminal_super(terminal, data, tree)
1309 }
1310 fn visit_hash_terminal(
1311 &mut self,
1312 terminal: Hash,
1313 data: TerminalData,
1314 tree: &F,
1315 ) -> Result<(), Self::Error> {
1316 self.visit_hash_terminal_super(terminal, data, tree)
1317 }
1318 fn visit_map_bind_terminal(
1319 &mut self,
1320 terminal: MapBind,
1321 data: TerminalData,
1322 tree: &F,
1323 ) -> Result<(), Self::Error> {
1324 self.visit_map_bind_terminal_super(terminal, data, tree)
1325 }
1326 fn visit_integer_terminal(
1327 &mut self,
1328 terminal: Integer,
1329 data: TerminalData,
1330 tree: &F,
1331 ) -> Result<(), Self::Error> {
1332 self.visit_integer_terminal_super(terminal, data, tree)
1333 }
1334 fn visit_float_terminal(
1335 &mut self,
1336 terminal: Float,
1337 data: TerminalData,
1338 tree: &F,
1339 ) -> Result<(), Self::Error> {
1340 self.visit_float_terminal_super(terminal, data, tree)
1341 }
1342 fn visit_inf_terminal(
1343 &mut self,
1344 terminal: Inf,
1345 data: TerminalData,
1346 tree: &F,
1347 ) -> Result<(), Self::Error> {
1348 self.visit_inf_terminal_super(terminal, data, tree)
1349 }
1350 fn visit_na_n_terminal(
1351 &mut self,
1352 terminal: NaN,
1353 data: TerminalData,
1354 tree: &F,
1355 ) -> Result<(), Self::Error> {
1356 self.visit_na_n_terminal_super(terminal, data, tree)
1357 }
1358 fn visit_true_terminal(
1359 &mut self,
1360 terminal: True,
1361 data: TerminalData,
1362 tree: &F,
1363 ) -> Result<(), Self::Error> {
1364 self.visit_true_terminal_super(terminal, data, tree)
1365 }
1366 fn visit_false_terminal(
1367 &mut self,
1368 terminal: False,
1369 data: TerminalData,
1370 tree: &F,
1371 ) -> Result<(), Self::Error> {
1372 self.visit_false_terminal_super(terminal, data, tree)
1373 }
1374 fn visit_null_terminal(
1375 &mut self,
1376 terminal: Null,
1377 data: TerminalData,
1378 tree: &F,
1379 ) -> Result<(), Self::Error> {
1380 self.visit_null_terminal_super(terminal, data, tree)
1381 }
1382 fn visit_hole_terminal(
1383 &mut self,
1384 terminal: Hole,
1385 data: TerminalData,
1386 tree: &F,
1387 ) -> Result<(), Self::Error> {
1388 self.visit_hole_terminal_super(terminal, data, tree)
1389 }
1390 fn visit_str_terminal(
1391 &mut self,
1392 terminal: Str,
1393 data: TerminalData,
1394 tree: &F,
1395 ) -> Result<(), Self::Error> {
1396 self.visit_str_terminal_super(terminal, data, tree)
1397 }
1398 fn visit_lit_str_terminal(
1399 &mut self,
1400 terminal: LitStr,
1401 data: TerminalData,
1402 tree: &F,
1403 ) -> Result<(), Self::Error> {
1404 self.visit_lit_str_terminal_super(terminal, data, tree)
1405 }
1406 fn visit_text_terminal(
1407 &mut self,
1408 terminal: Text,
1409 data: TerminalData,
1410 tree: &F,
1411 ) -> Result<(), Self::Error> {
1412 self.visit_text_terminal_super(terminal, data, tree)
1413 }
1414 fn visit_inline_code_1_terminal(
1415 &mut self,
1416 terminal: InlineCode1,
1417 data: TerminalData,
1418 tree: &F,
1419 ) -> Result<(), Self::Error> {
1420 self.visit_inline_code_1_terminal_super(terminal, data, tree)
1421 }
1422 fn visit_lit_str_3_start_terminal(
1423 &mut self,
1424 terminal: LitStr3Start,
1425 data: TerminalData,
1426 tree: &F,
1427 ) -> Result<(), Self::Error> {
1428 self.visit_lit_str_3_start_terminal_super(terminal, data, tree)
1429 }
1430 fn visit_lit_str_2_start_terminal(
1431 &mut self,
1432 terminal: LitStr2Start,
1433 data: TerminalData,
1434 tree: &F,
1435 ) -> Result<(), Self::Error> {
1436 self.visit_lit_str_2_start_terminal_super(terminal, data, tree)
1437 }
1438 fn visit_lit_str_1_start_terminal(
1439 &mut self,
1440 terminal: LitStr1Start,
1441 data: TerminalData,
1442 tree: &F,
1443 ) -> Result<(), Self::Error> {
1444 self.visit_lit_str_1_start_terminal_super(terminal, data, tree)
1445 }
1446 fn visit_delim_code_start_3_terminal(
1447 &mut self,
1448 terminal: DelimCodeStart3,
1449 data: TerminalData,
1450 tree: &F,
1451 ) -> Result<(), Self::Error> {
1452 self.visit_delim_code_start_3_terminal_super(terminal, data, tree)
1453 }
1454 fn visit_delim_code_start_2_terminal(
1455 &mut self,
1456 terminal: DelimCodeStart2,
1457 data: TerminalData,
1458 tree: &F,
1459 ) -> Result<(), Self::Error> {
1460 self.visit_delim_code_start_2_terminal_super(terminal, data, tree)
1461 }
1462 fn visit_delim_code_start_1_terminal(
1463 &mut self,
1464 terminal: DelimCodeStart1,
1465 data: TerminalData,
1466 tree: &F,
1467 ) -> Result<(), Self::Error> {
1468 self.visit_delim_code_start_1_terminal_super(terminal, data, tree)
1469 }
1470 fn visit_code_block_start_3_terminal(
1471 &mut self,
1472 terminal: CodeBlockStart3,
1473 data: TerminalData,
1474 tree: &F,
1475 ) -> Result<(), Self::Error> {
1476 self.visit_code_block_start_3_terminal_super(terminal, data, tree)
1477 }
1478 fn visit_code_block_start_4_terminal(
1479 &mut self,
1480 terminal: CodeBlockStart4,
1481 data: TerminalData,
1482 tree: &F,
1483 ) -> Result<(), Self::Error> {
1484 self.visit_code_block_start_4_terminal_super(terminal, data, tree)
1485 }
1486 fn visit_code_block_start_5_terminal(
1487 &mut self,
1488 terminal: CodeBlockStart5,
1489 data: TerminalData,
1490 tree: &F,
1491 ) -> Result<(), Self::Error> {
1492 self.visit_code_block_start_5_terminal_super(terminal, data, tree)
1493 }
1494 fn visit_code_block_start_6_terminal(
1495 &mut self,
1496 terminal: CodeBlockStart6,
1497 data: TerminalData,
1498 tree: &F,
1499 ) -> Result<(), Self::Error> {
1500 self.visit_code_block_start_6_terminal_super(terminal, data, tree)
1501 }
1502 fn visit_code_block_end_3_terminal(
1503 &mut self,
1504 terminal: CodeBlockEnd3,
1505 data: TerminalData,
1506 tree: &F,
1507 ) -> Result<(), Self::Error> {
1508 self.visit_code_block_end_3_terminal_super(terminal, data, tree)
1509 }
1510 fn visit_backtick_2_terminal(
1511 &mut self,
1512 terminal: Backtick2,
1513 data: TerminalData,
1514 tree: &F,
1515 ) -> Result<(), Self::Error> {
1516 self.visit_backtick_2_terminal_super(terminal, data, tree)
1517 }
1518 fn visit_code_block_end_4_terminal(
1519 &mut self,
1520 terminal: CodeBlockEnd4,
1521 data: TerminalData,
1522 tree: &F,
1523 ) -> Result<(), Self::Error> {
1524 self.visit_code_block_end_4_terminal_super(terminal, data, tree)
1525 }
1526 fn visit_backtick_3_terminal(
1527 &mut self,
1528 terminal: Backtick3,
1529 data: TerminalData,
1530 tree: &F,
1531 ) -> Result<(), Self::Error> {
1532 self.visit_backtick_3_terminal_super(terminal, data, tree)
1533 }
1534 fn visit_code_block_end_5_terminal(
1535 &mut self,
1536 terminal: CodeBlockEnd5,
1537 data: TerminalData,
1538 tree: &F,
1539 ) -> Result<(), Self::Error> {
1540 self.visit_code_block_end_5_terminal_super(terminal, data, tree)
1541 }
1542 fn visit_backtick_4_terminal(
1543 &mut self,
1544 terminal: Backtick4,
1545 data: TerminalData,
1546 tree: &F,
1547 ) -> Result<(), Self::Error> {
1548 self.visit_backtick_4_terminal_super(terminal, data, tree)
1549 }
1550 fn visit_code_block_end_6_terminal(
1551 &mut self,
1552 terminal: CodeBlockEnd6,
1553 data: TerminalData,
1554 tree: &F,
1555 ) -> Result<(), Self::Error> {
1556 self.visit_code_block_end_6_terminal_super(terminal, data, tree)
1557 }
1558 fn visit_backtick_5_terminal(
1559 &mut self,
1560 terminal: Backtick5,
1561 data: TerminalData,
1562 tree: &F,
1563 ) -> Result<(), Self::Error> {
1564 self.visit_backtick_5_terminal_super(terminal, data, tree)
1565 }
1566 fn visit_no_backtick_terminal(
1567 &mut self,
1568 terminal: NoBacktick,
1569 data: TerminalData,
1570 tree: &F,
1571 ) -> Result<(), Self::Error> {
1572 self.visit_no_backtick_terminal_super(terminal, data, tree)
1573 }
1574 fn visit_lit_str_3_end_terminal(
1575 &mut self,
1576 terminal: LitStr3End,
1577 data: TerminalData,
1578 tree: &F,
1579 ) -> Result<(), Self::Error> {
1580 self.visit_lit_str_3_end_terminal_super(terminal, data, tree)
1581 }
1582 fn visit_lit_str_2_end_terminal(
1583 &mut self,
1584 terminal: LitStr2End,
1585 data: TerminalData,
1586 tree: &F,
1587 ) -> Result<(), Self::Error> {
1588 self.visit_lit_str_2_end_terminal_super(terminal, data, tree)
1589 }
1590 fn visit_lit_str_1_end_terminal(
1591 &mut self,
1592 terminal: LitStr1End,
1593 data: TerminalData,
1594 tree: &F,
1595 ) -> Result<(), Self::Error> {
1596 self.visit_lit_str_1_end_terminal_super(terminal, data, tree)
1597 }
1598 fn visit_s_quote_terminal(
1599 &mut self,
1600 terminal: SQuote,
1601 data: TerminalData,
1602 tree: &F,
1603 ) -> Result<(), Self::Error> {
1604 self.visit_s_quote_terminal_super(terminal, data, tree)
1605 }
1606 fn visit_no_s_quote_terminal(
1607 &mut self,
1608 terminal: NoSQuote,
1609 data: TerminalData,
1610 tree: &F,
1611 ) -> Result<(), Self::Error> {
1612 self.visit_no_s_quote_terminal_super(terminal, data, tree)
1613 }
1614 fn visit_delim_code_end_3_terminal(
1615 &mut self,
1616 terminal: DelimCodeEnd3,
1617 data: TerminalData,
1618 tree: &F,
1619 ) -> Result<(), Self::Error> {
1620 self.visit_delim_code_end_3_terminal_super(terminal, data, tree)
1621 }
1622 fn visit_delim_code_end_2_terminal(
1623 &mut self,
1624 terminal: DelimCodeEnd2,
1625 data: TerminalData,
1626 tree: &F,
1627 ) -> Result<(), Self::Error> {
1628 self.visit_delim_code_end_2_terminal_super(terminal, data, tree)
1629 }
1630 fn visit_delim_code_end_1_terminal(
1631 &mut self,
1632 terminal: DelimCodeEnd1,
1633 data: TerminalData,
1634 tree: &F,
1635 ) -> Result<(), Self::Error> {
1636 self.visit_delim_code_end_1_terminal_super(terminal, data, tree)
1637 }
1638 fn visit_backtick_delim_terminal(
1639 &mut self,
1640 terminal: BacktickDelim,
1641 data: TerminalData,
1642 tree: &F,
1643 ) -> Result<(), Self::Error> {
1644 self.visit_backtick_delim_terminal_super(terminal, data, tree)
1645 }
1646 fn visit_grammar_newline_terminal(
1647 &mut self,
1648 terminal: GrammarNewline,
1649 data: TerminalData,
1650 tree: &F,
1651 ) -> Result<(), Self::Error> {
1652 self.visit_grammar_newline_terminal_super(terminal, data, tree)
1653 }
1654 fn visit_ws_terminal(
1655 &mut self,
1656 terminal: Ws,
1657 data: TerminalData,
1658 tree: &F,
1659 ) -> Result<(), Self::Error> {
1660 self.visit_ws_terminal_super(terminal, data, tree)
1661 }
1662 fn visit_at_terminal(
1663 &mut self,
1664 terminal: At,
1665 data: TerminalData,
1666 tree: &F,
1667 ) -> Result<(), Self::Error> {
1668 self.visit_at_terminal_super(terminal, data, tree)
1669 }
1670 fn visit_dollar_terminal(
1671 &mut self,
1672 terminal: Dollar,
1673 data: TerminalData,
1674 tree: &F,
1675 ) -> Result<(), Self::Error> {
1676 self.visit_dollar_terminal_super(terminal, data, tree)
1677 }
1678 fn visit_dot_terminal(
1679 &mut self,
1680 terminal: Dot,
1681 data: TerminalData,
1682 tree: &F,
1683 ) -> Result<(), Self::Error> {
1684 self.visit_dot_terminal_super(terminal, data, tree)
1685 }
1686 fn visit_l_brace_terminal(
1687 &mut self,
1688 terminal: LBrace,
1689 data: TerminalData,
1690 tree: &F,
1691 ) -> Result<(), Self::Error> {
1692 self.visit_l_brace_terminal_super(terminal, data, tree)
1693 }
1694 fn visit_r_brace_terminal(
1695 &mut self,
1696 terminal: RBrace,
1697 data: TerminalData,
1698 tree: &F,
1699 ) -> Result<(), Self::Error> {
1700 self.visit_r_brace_terminal_super(terminal, data, tree)
1701 }
1702 fn visit_l_bracket_terminal(
1703 &mut self,
1704 terminal: LBracket,
1705 data: TerminalData,
1706 tree: &F,
1707 ) -> Result<(), Self::Error> {
1708 self.visit_l_bracket_terminal_super(terminal, data, tree)
1709 }
1710 fn visit_r_bracket_terminal(
1711 &mut self,
1712 terminal: RBracket,
1713 data: TerminalData,
1714 tree: &F,
1715 ) -> Result<(), Self::Error> {
1716 self.visit_r_bracket_terminal_super(terminal, data, tree)
1717 }
1718 fn visit_l_paren_terminal(
1719 &mut self,
1720 terminal: LParen,
1721 data: TerminalData,
1722 tree: &F,
1723 ) -> Result<(), Self::Error> {
1724 self.visit_l_paren_terminal_super(terminal, data, tree)
1725 }
1726 fn visit_r_paren_terminal(
1727 &mut self,
1728 terminal: RParen,
1729 data: TerminalData,
1730 tree: &F,
1731 ) -> Result<(), Self::Error> {
1732 self.visit_r_paren_terminal_super(terminal, data, tree)
1733 }
1734 fn visit_newline_bind_terminal(
1735 &mut self,
1736 terminal: NewlineBind,
1737 data: TerminalData,
1738 tree: &F,
1739 ) -> Result<(), Self::Error> {
1740 self.visit_newline_bind_terminal_super(terminal, data, tree)
1741 }
1742 fn visit_bind_terminal(
1743 &mut self,
1744 terminal: Bind,
1745 data: TerminalData,
1746 tree: &F,
1747 ) -> Result<(), Self::Error> {
1748 self.visit_bind_terminal_super(terminal, data, tree)
1749 }
1750 fn visit_comma_terminal(
1751 &mut self,
1752 terminal: Comma,
1753 data: TerminalData,
1754 tree: &F,
1755 ) -> Result<(), Self::Error> {
1756 self.visit_comma_terminal_super(terminal, data, tree)
1757 }
1758 fn visit_esc_terminal(
1759 &mut self,
1760 terminal: Esc,
1761 data: TerminalData,
1762 tree: &F,
1763 ) -> Result<(), Self::Error> {
1764 self.visit_esc_terminal_super(terminal, data, tree)
1765 }
1766 fn visit_newline_text_start_terminal(
1767 &mut self,
1768 terminal: NewlineTextStart,
1769 data: TerminalData,
1770 tree: &F,
1771 ) -> Result<(), Self::Error> {
1772 self.visit_newline_text_start_terminal_super(terminal, data, tree)
1773 }
1774 fn visit_text_start_terminal(
1775 &mut self,
1776 terminal: TextStart,
1777 data: TerminalData,
1778 tree: &F,
1779 ) -> Result<(), Self::Error> {
1780 self.visit_text_start_terminal_super(terminal, data, tree)
1781 }
1782 fn visit_ident_terminal(
1783 &mut self,
1784 terminal: Ident,
1785 data: TerminalData,
1786 tree: &F,
1787 ) -> Result<(), Self::Error> {
1788 self.visit_ident_terminal_super(terminal, data, tree)
1789 }
1790 fn visit_non_terminal(
1791 &mut self,
1792 id: CstNodeId,
1793 kind: NonTerminalKind,
1794 data: NonTerminalData,
1795 tree: &F,
1796 ) -> Result<(), Self::Error> {
1797 self.visit_non_terminal_super(id, kind, data, tree)
1798 }
1799 fn visit_non_terminal_close(
1800 &mut self,
1801 id: CstNodeId,
1802 kind: NonTerminalKind,
1803 data: NonTerminalData,
1804 tree: &F,
1805 ) -> Result<(), Self::Error> {
1806 self.visit_non_terminal_close_super(id, kind, data, tree)
1807 }
1808 fn visit_terminal(
1809 &mut self,
1810 id: CstNodeId,
1811 kind: TerminalKind,
1812 data: TerminalData,
1813 tree: &F,
1814 ) -> Result<(), Self::Error> {
1815 self.visit_terminal_super(id, kind, data, tree)
1816 }
1817 fn then_construct_error(
1820 &mut self,
1821 node_data: Option<CstNode>,
1822 parent: CstNodeId,
1823 kind: NodeKind,
1824 error: CstConstructError,
1825 tree: &F,
1826 ) -> Result<(), Self::Error> {
1827 let _error = error;
1828 self.recover_error(node_data, parent, kind, tree)
1829 }
1830}
1831mod private {
1832 pub trait Sealed<F> {}
1833}
1834pub trait CstVisitorSuper<F: CstFacade, E>: private::Sealed<F> {
1835 fn visit_array_handle(&mut self, handle: ArrayHandle, tree: &F) -> Result<(), E>;
1836 fn visit_array_super(
1837 &mut self,
1838 handle: ArrayHandle,
1839 view: ArrayView,
1840 tree: &F,
1841 ) -> Result<(), E>;
1842 fn visit_array_begin_handle(&mut self, handle: ArrayBeginHandle, tree: &F) -> Result<(), E>;
1843 fn visit_array_begin_super(
1844 &mut self,
1845 handle: ArrayBeginHandle,
1846 view: ArrayBeginView,
1847 tree: &F,
1848 ) -> Result<(), E>;
1849 fn visit_array_elements_handle(
1850 &mut self,
1851 handle: ArrayElementsHandle,
1852 tree: &F,
1853 ) -> Result<(), E>;
1854 fn visit_array_elements_super(
1855 &mut self,
1856 handle: ArrayElementsHandle,
1857 view: ArrayElementsView,
1858 tree: &F,
1859 ) -> Result<(), E>;
1860 fn visit_array_elements_opt_handle(
1861 &mut self,
1862 handle: ArrayElementsOptHandle,
1863 tree: &F,
1864 ) -> Result<(), E>;
1865 fn visit_array_elements_opt_super(
1866 &mut self,
1867 handle: ArrayElementsOptHandle,
1868 view: ArrayElementsTailHandle,
1869 tree: &F,
1870 ) -> Result<(), E>;
1871 fn visit_array_elements_tail_handle(
1872 &mut self,
1873 handle: ArrayElementsTailHandle,
1874 tree: &F,
1875 ) -> Result<(), E>;
1876 fn visit_array_elements_tail_super(
1877 &mut self,
1878 handle: ArrayElementsTailHandle,
1879 view: ArrayElementsTailView,
1880 tree: &F,
1881 ) -> Result<(), E>;
1882 fn visit_array_elements_tail_opt_handle(
1883 &mut self,
1884 handle: ArrayElementsTailOptHandle,
1885 tree: &F,
1886 ) -> Result<(), E>;
1887 fn visit_array_elements_tail_opt_super(
1888 &mut self,
1889 handle: ArrayElementsTailOptHandle,
1890 view: ArrayElementsHandle,
1891 tree: &F,
1892 ) -> Result<(), E>;
1893 fn visit_array_end_handle(&mut self, handle: ArrayEndHandle, tree: &F) -> Result<(), E>;
1894 fn visit_array_end_super(
1895 &mut self,
1896 handle: ArrayEndHandle,
1897 view: ArrayEndView,
1898 tree: &F,
1899 ) -> Result<(), E>;
1900 fn visit_array_marker_handle(&mut self, handle: ArrayMarkerHandle, tree: &F) -> Result<(), E>;
1901 fn visit_array_marker_super(
1902 &mut self,
1903 handle: ArrayMarkerHandle,
1904 view: ArrayMarkerView,
1905 tree: &F,
1906 ) -> Result<(), E>;
1907 fn visit_array_marker_opt_handle(
1908 &mut self,
1909 handle: ArrayMarkerOptHandle,
1910 tree: &F,
1911 ) -> Result<(), E>;
1912 fn visit_array_marker_opt_super(
1913 &mut self,
1914 handle: ArrayMarkerOptHandle,
1915 view: IntegerHandle,
1916 tree: &F,
1917 ) -> Result<(), E>;
1918 fn visit_array_opt_handle(&mut self, handle: ArrayOptHandle, tree: &F) -> Result<(), E>;
1919 fn visit_array_opt_super(
1920 &mut self,
1921 handle: ArrayOptHandle,
1922 view: ArrayElementsHandle,
1923 tree: &F,
1924 ) -> Result<(), E>;
1925 fn visit_at_handle(&mut self, handle: AtHandle, tree: &F) -> Result<(), E>;
1926 fn visit_at_super(&mut self, handle: AtHandle, view: AtView, tree: &F) -> Result<(), E>;
1927 fn visit_backtick_2_handle(&mut self, handle: Backtick2Handle, tree: &F) -> Result<(), E>;
1928 fn visit_backtick_2_super(
1929 &mut self,
1930 handle: Backtick2Handle,
1931 view: Backtick2View,
1932 tree: &F,
1933 ) -> Result<(), E>;
1934 fn visit_backtick_3_handle(&mut self, handle: Backtick3Handle, tree: &F) -> Result<(), E>;
1935 fn visit_backtick_3_super(
1936 &mut self,
1937 handle: Backtick3Handle,
1938 view: Backtick3View,
1939 tree: &F,
1940 ) -> Result<(), E>;
1941 fn visit_backtick_4_handle(&mut self, handle: Backtick4Handle, tree: &F) -> Result<(), E>;
1942 fn visit_backtick_4_super(
1943 &mut self,
1944 handle: Backtick4Handle,
1945 view: Backtick4View,
1946 tree: &F,
1947 ) -> Result<(), E>;
1948 fn visit_backtick_5_handle(&mut self, handle: Backtick5Handle, tree: &F) -> Result<(), E>;
1949 fn visit_backtick_5_super(
1950 &mut self,
1951 handle: Backtick5Handle,
1952 view: Backtick5View,
1953 tree: &F,
1954 ) -> Result<(), E>;
1955 fn visit_backtick_delim_handle(
1956 &mut self,
1957 handle: BacktickDelimHandle,
1958 tree: &F,
1959 ) -> Result<(), E>;
1960 fn visit_backtick_delim_super(
1961 &mut self,
1962 handle: BacktickDelimHandle,
1963 view: BacktickDelimView,
1964 tree: &F,
1965 ) -> Result<(), E>;
1966 fn visit_begin_handle(&mut self, handle: BeginHandle, tree: &F) -> Result<(), E>;
1967 fn visit_begin_super(
1968 &mut self,
1969 handle: BeginHandle,
1970 view: BeginView,
1971 tree: &F,
1972 ) -> Result<(), E>;
1973 fn visit_bind_handle(&mut self, handle: BindHandle, tree: &F) -> Result<(), E>;
1974 fn visit_bind_super(&mut self, handle: BindHandle, view: BindView, tree: &F) -> Result<(), E>;
1975 fn visit_binding_handle(&mut self, handle: BindingHandle, tree: &F) -> Result<(), E>;
1976 fn visit_binding_super(
1977 &mut self,
1978 handle: BindingHandle,
1979 view: BindingView,
1980 tree: &F,
1981 ) -> Result<(), E>;
1982 fn visit_binding_rhs_handle(&mut self, handle: BindingRhsHandle, tree: &F) -> Result<(), E>;
1983 fn visit_binding_rhs_super(
1984 &mut self,
1985 handle: BindingRhsHandle,
1986 view: BindingRhsView,
1987 tree: &F,
1988 ) -> Result<(), E>;
1989 fn visit_block_body_handle(&mut self, handle: BlockBodyHandle, tree: &F) -> Result<(), E>;
1990 fn visit_block_body_super(
1991 &mut self,
1992 handle: BlockBodyHandle,
1993 view: BlockBodyView,
1994 tree: &F,
1995 ) -> Result<(), E>;
1996 fn visit_boolean_handle(&mut self, handle: BooleanHandle, tree: &F) -> Result<(), E>;
1997 fn visit_boolean_super(
1998 &mut self,
1999 handle: BooleanHandle,
2000 view: BooleanView,
2001 tree: &F,
2002 ) -> Result<(), E>;
2003 fn visit_code_block_handle(&mut self, handle: CodeBlockHandle, tree: &F) -> Result<(), E>;
2004 fn visit_code_block_super(
2005 &mut self,
2006 handle: CodeBlockHandle,
2007 view: CodeBlockView,
2008 tree: &F,
2009 ) -> Result<(), E>;
2010 fn visit_code_block_3_handle(&mut self, handle: CodeBlock3Handle, tree: &F) -> Result<(), E>;
2011 fn visit_code_block_3_super(
2012 &mut self,
2013 handle: CodeBlock3Handle,
2014 view: CodeBlock3View,
2015 tree: &F,
2016 ) -> Result<(), E>;
2017 fn visit_code_block_3_list_handle(
2018 &mut self,
2019 handle: CodeBlock3ListHandle,
2020 tree: &F,
2021 ) -> Result<(), E>;
2022 fn visit_code_block_3_list_super(
2023 &mut self,
2024 handle: CodeBlock3ListHandle,
2025 view: CodeBlock3ListView,
2026 tree: &F,
2027 ) -> Result<(), E>;
2028 fn visit_code_block_3_list_group_handle(
2029 &mut self,
2030 handle: CodeBlock3ListGroupHandle,
2031 tree: &F,
2032 ) -> Result<(), E>;
2033 fn visit_code_block_3_list_group_super(
2034 &mut self,
2035 handle: CodeBlock3ListGroupHandle,
2036 view: CodeBlock3ListGroupView,
2037 tree: &F,
2038 ) -> Result<(), E>;
2039 fn visit_code_block_4_handle(&mut self, handle: CodeBlock4Handle, tree: &F) -> Result<(), E>;
2040 fn visit_code_block_4_super(
2041 &mut self,
2042 handle: CodeBlock4Handle,
2043 view: CodeBlock4View,
2044 tree: &F,
2045 ) -> Result<(), E>;
2046 fn visit_code_block_4_list_handle(
2047 &mut self,
2048 handle: CodeBlock4ListHandle,
2049 tree: &F,
2050 ) -> Result<(), E>;
2051 fn visit_code_block_4_list_super(
2052 &mut self,
2053 handle: CodeBlock4ListHandle,
2054 view: CodeBlock4ListView,
2055 tree: &F,
2056 ) -> Result<(), E>;
2057 fn visit_code_block_4_list_group_handle(
2058 &mut self,
2059 handle: CodeBlock4ListGroupHandle,
2060 tree: &F,
2061 ) -> Result<(), E>;
2062 fn visit_code_block_4_list_group_super(
2063 &mut self,
2064 handle: CodeBlock4ListGroupHandle,
2065 view: CodeBlock4ListGroupView,
2066 tree: &F,
2067 ) -> Result<(), E>;
2068 fn visit_code_block_5_handle(&mut self, handle: CodeBlock5Handle, tree: &F) -> Result<(), E>;
2069 fn visit_code_block_5_super(
2070 &mut self,
2071 handle: CodeBlock5Handle,
2072 view: CodeBlock5View,
2073 tree: &F,
2074 ) -> Result<(), E>;
2075 fn visit_code_block_5_list_handle(
2076 &mut self,
2077 handle: CodeBlock5ListHandle,
2078 tree: &F,
2079 ) -> Result<(), E>;
2080 fn visit_code_block_5_list_super(
2081 &mut self,
2082 handle: CodeBlock5ListHandle,
2083 view: CodeBlock5ListView,
2084 tree: &F,
2085 ) -> Result<(), E>;
2086 fn visit_code_block_5_list_group_handle(
2087 &mut self,
2088 handle: CodeBlock5ListGroupHandle,
2089 tree: &F,
2090 ) -> Result<(), E>;
2091 fn visit_code_block_5_list_group_super(
2092 &mut self,
2093 handle: CodeBlock5ListGroupHandle,
2094 view: CodeBlock5ListGroupView,
2095 tree: &F,
2096 ) -> Result<(), E>;
2097 fn visit_code_block_6_handle(&mut self, handle: CodeBlock6Handle, tree: &F) -> Result<(), E>;
2098 fn visit_code_block_6_super(
2099 &mut self,
2100 handle: CodeBlock6Handle,
2101 view: CodeBlock6View,
2102 tree: &F,
2103 ) -> Result<(), E>;
2104 fn visit_code_block_6_list_handle(
2105 &mut self,
2106 handle: CodeBlock6ListHandle,
2107 tree: &F,
2108 ) -> Result<(), E>;
2109 fn visit_code_block_6_list_super(
2110 &mut self,
2111 handle: CodeBlock6ListHandle,
2112 view: CodeBlock6ListView,
2113 tree: &F,
2114 ) -> Result<(), E>;
2115 fn visit_code_block_6_list_group_handle(
2116 &mut self,
2117 handle: CodeBlock6ListGroupHandle,
2118 tree: &F,
2119 ) -> Result<(), E>;
2120 fn visit_code_block_6_list_group_super(
2121 &mut self,
2122 handle: CodeBlock6ListGroupHandle,
2123 view: CodeBlock6ListGroupView,
2124 tree: &F,
2125 ) -> Result<(), E>;
2126 fn visit_code_block_end_3_handle(
2127 &mut self,
2128 handle: CodeBlockEnd3Handle,
2129 tree: &F,
2130 ) -> Result<(), E>;
2131 fn visit_code_block_end_3_super(
2132 &mut self,
2133 handle: CodeBlockEnd3Handle,
2134 view: CodeBlockEnd3View,
2135 tree: &F,
2136 ) -> Result<(), E>;
2137 fn visit_code_block_end_4_handle(
2138 &mut self,
2139 handle: CodeBlockEnd4Handle,
2140 tree: &F,
2141 ) -> Result<(), E>;
2142 fn visit_code_block_end_4_super(
2143 &mut self,
2144 handle: CodeBlockEnd4Handle,
2145 view: CodeBlockEnd4View,
2146 tree: &F,
2147 ) -> Result<(), E>;
2148 fn visit_code_block_end_5_handle(
2149 &mut self,
2150 handle: CodeBlockEnd5Handle,
2151 tree: &F,
2152 ) -> Result<(), E>;
2153 fn visit_code_block_end_5_super(
2154 &mut self,
2155 handle: CodeBlockEnd5Handle,
2156 view: CodeBlockEnd5View,
2157 tree: &F,
2158 ) -> Result<(), E>;
2159 fn visit_code_block_end_6_handle(
2160 &mut self,
2161 handle: CodeBlockEnd6Handle,
2162 tree: &F,
2163 ) -> Result<(), E>;
2164 fn visit_code_block_end_6_super(
2165 &mut self,
2166 handle: CodeBlockEnd6Handle,
2167 view: CodeBlockEnd6View,
2168 tree: &F,
2169 ) -> Result<(), E>;
2170 fn visit_code_block_start_3_handle(
2171 &mut self,
2172 handle: CodeBlockStart3Handle,
2173 tree: &F,
2174 ) -> Result<(), E>;
2175 fn visit_code_block_start_3_super(
2176 &mut self,
2177 handle: CodeBlockStart3Handle,
2178 view: CodeBlockStart3View,
2179 tree: &F,
2180 ) -> Result<(), E>;
2181 fn visit_code_block_start_4_handle(
2182 &mut self,
2183 handle: CodeBlockStart4Handle,
2184 tree: &F,
2185 ) -> Result<(), E>;
2186 fn visit_code_block_start_4_super(
2187 &mut self,
2188 handle: CodeBlockStart4Handle,
2189 view: CodeBlockStart4View,
2190 tree: &F,
2191 ) -> Result<(), E>;
2192 fn visit_code_block_start_5_handle(
2193 &mut self,
2194 handle: CodeBlockStart5Handle,
2195 tree: &F,
2196 ) -> Result<(), E>;
2197 fn visit_code_block_start_5_super(
2198 &mut self,
2199 handle: CodeBlockStart5Handle,
2200 view: CodeBlockStart5View,
2201 tree: &F,
2202 ) -> Result<(), E>;
2203 fn visit_code_block_start_6_handle(
2204 &mut self,
2205 handle: CodeBlockStart6Handle,
2206 tree: &F,
2207 ) -> Result<(), E>;
2208 fn visit_code_block_start_6_super(
2209 &mut self,
2210 handle: CodeBlockStart6Handle,
2211 view: CodeBlockStart6View,
2212 tree: &F,
2213 ) -> Result<(), E>;
2214 fn visit_comma_handle(&mut self, handle: CommaHandle, tree: &F) -> Result<(), E>;
2215 fn visit_comma_super(
2216 &mut self,
2217 handle: CommaHandle,
2218 view: CommaView,
2219 tree: &F,
2220 ) -> Result<(), E>;
2221 fn visit_continue_handle(&mut self, handle: ContinueHandle, tree: &F) -> Result<(), E>;
2222 fn visit_continue_super(
2223 &mut self,
2224 handle: ContinueHandle,
2225 view: ContinueView,
2226 tree: &F,
2227 ) -> Result<(), E>;
2228 fn visit_delim_code_handle(&mut self, handle: DelimCodeHandle, tree: &F) -> Result<(), E>;
2229 fn visit_delim_code_super(
2230 &mut self,
2231 handle: DelimCodeHandle,
2232 view: DelimCodeView,
2233 tree: &F,
2234 ) -> Result<(), E>;
2235 fn visit_delim_code_1_handle(&mut self, handle: DelimCode1Handle, tree: &F) -> Result<(), E>;
2236 fn visit_delim_code_1_super(
2237 &mut self,
2238 handle: DelimCode1Handle,
2239 view: DelimCode1View,
2240 tree: &F,
2241 ) -> Result<(), E>;
2242 fn visit_delim_code_1_list_handle(
2243 &mut self,
2244 handle: DelimCode1ListHandle,
2245 tree: &F,
2246 ) -> Result<(), E>;
2247 fn visit_delim_code_1_list_super(
2248 &mut self,
2249 handle: DelimCode1ListHandle,
2250 view: DelimCode1ListView,
2251 tree: &F,
2252 ) -> Result<(), E>;
2253 fn visit_delim_code_1_list_group_handle(
2254 &mut self,
2255 handle: DelimCode1ListGroupHandle,
2256 tree: &F,
2257 ) -> Result<(), E>;
2258 fn visit_delim_code_1_list_group_super(
2259 &mut self,
2260 handle: DelimCode1ListGroupHandle,
2261 view: DelimCode1ListGroupView,
2262 tree: &F,
2263 ) -> Result<(), E>;
2264 fn visit_delim_code_2_handle(&mut self, handle: DelimCode2Handle, tree: &F) -> Result<(), E>;
2265 fn visit_delim_code_2_super(
2266 &mut self,
2267 handle: DelimCode2Handle,
2268 view: DelimCode2View,
2269 tree: &F,
2270 ) -> Result<(), E>;
2271 fn visit_delim_code_2_list_handle(
2272 &mut self,
2273 handle: DelimCode2ListHandle,
2274 tree: &F,
2275 ) -> Result<(), E>;
2276 fn visit_delim_code_2_list_super(
2277 &mut self,
2278 handle: DelimCode2ListHandle,
2279 view: DelimCode2ListView,
2280 tree: &F,
2281 ) -> Result<(), E>;
2282 fn visit_delim_code_2_list_group_handle(
2283 &mut self,
2284 handle: DelimCode2ListGroupHandle,
2285 tree: &F,
2286 ) -> Result<(), E>;
2287 fn visit_delim_code_2_list_group_super(
2288 &mut self,
2289 handle: DelimCode2ListGroupHandle,
2290 view: DelimCode2ListGroupView,
2291 tree: &F,
2292 ) -> Result<(), E>;
2293 fn visit_delim_code_3_handle(&mut self, handle: DelimCode3Handle, tree: &F) -> Result<(), E>;
2294 fn visit_delim_code_3_super(
2295 &mut self,
2296 handle: DelimCode3Handle,
2297 view: DelimCode3View,
2298 tree: &F,
2299 ) -> Result<(), E>;
2300 fn visit_delim_code_3_list_handle(
2301 &mut self,
2302 handle: DelimCode3ListHandle,
2303 tree: &F,
2304 ) -> Result<(), E>;
2305 fn visit_delim_code_3_list_super(
2306 &mut self,
2307 handle: DelimCode3ListHandle,
2308 view: DelimCode3ListView,
2309 tree: &F,
2310 ) -> Result<(), E>;
2311 fn visit_delim_code_3_list_group_handle(
2312 &mut self,
2313 handle: DelimCode3ListGroupHandle,
2314 tree: &F,
2315 ) -> Result<(), E>;
2316 fn visit_delim_code_3_list_group_super(
2317 &mut self,
2318 handle: DelimCode3ListGroupHandle,
2319 view: DelimCode3ListGroupView,
2320 tree: &F,
2321 ) -> Result<(), E>;
2322 fn visit_delim_code_end_1_handle(
2323 &mut self,
2324 handle: DelimCodeEnd1Handle,
2325 tree: &F,
2326 ) -> Result<(), E>;
2327 fn visit_delim_code_end_1_super(
2328 &mut self,
2329 handle: DelimCodeEnd1Handle,
2330 view: DelimCodeEnd1View,
2331 tree: &F,
2332 ) -> Result<(), E>;
2333 fn visit_delim_code_end_2_handle(
2334 &mut self,
2335 handle: DelimCodeEnd2Handle,
2336 tree: &F,
2337 ) -> Result<(), E>;
2338 fn visit_delim_code_end_2_super(
2339 &mut self,
2340 handle: DelimCodeEnd2Handle,
2341 view: DelimCodeEnd2View,
2342 tree: &F,
2343 ) -> Result<(), E>;
2344 fn visit_delim_code_end_3_handle(
2345 &mut self,
2346 handle: DelimCodeEnd3Handle,
2347 tree: &F,
2348 ) -> Result<(), E>;
2349 fn visit_delim_code_end_3_super(
2350 &mut self,
2351 handle: DelimCodeEnd3Handle,
2352 view: DelimCodeEnd3View,
2353 tree: &F,
2354 ) -> Result<(), E>;
2355 fn visit_delim_code_start_1_handle(
2356 &mut self,
2357 handle: DelimCodeStart1Handle,
2358 tree: &F,
2359 ) -> Result<(), E>;
2360 fn visit_delim_code_start_1_super(
2361 &mut self,
2362 handle: DelimCodeStart1Handle,
2363 view: DelimCodeStart1View,
2364 tree: &F,
2365 ) -> Result<(), E>;
2366 fn visit_delim_code_start_2_handle(
2367 &mut self,
2368 handle: DelimCodeStart2Handle,
2369 tree: &F,
2370 ) -> Result<(), E>;
2371 fn visit_delim_code_start_2_super(
2372 &mut self,
2373 handle: DelimCodeStart2Handle,
2374 view: DelimCodeStart2View,
2375 tree: &F,
2376 ) -> Result<(), E>;
2377 fn visit_delim_code_start_3_handle(
2378 &mut self,
2379 handle: DelimCodeStart3Handle,
2380 tree: &F,
2381 ) -> Result<(), E>;
2382 fn visit_delim_code_start_3_super(
2383 &mut self,
2384 handle: DelimCodeStart3Handle,
2385 view: DelimCodeStart3View,
2386 tree: &F,
2387 ) -> Result<(), E>;
2388 fn visit_dot_handle(&mut self, handle: DotHandle, tree: &F) -> Result<(), E>;
2389 fn visit_dot_super(&mut self, handle: DotHandle, view: DotView, tree: &F) -> Result<(), E>;
2390 fn visit_dot_key_handle(&mut self, handle: DotKeyHandle, tree: &F) -> Result<(), E>;
2391 fn visit_dot_key_super(
2392 &mut self,
2393 handle: DotKeyHandle,
2394 view: DotKeyView,
2395 tree: &F,
2396 ) -> Result<(), E>;
2397 fn visit_end_handle(&mut self, handle: EndHandle, tree: &F) -> Result<(), E>;
2398 fn visit_end_super(&mut self, handle: EndHandle, view: EndView, tree: &F) -> Result<(), E>;
2399 fn visit_eure_handle(&mut self, handle: EureHandle, tree: &F) -> Result<(), E>;
2400 fn visit_eure_super(&mut self, handle: EureHandle, view: EureView, tree: &F) -> Result<(), E>;
2401 fn visit_eure_bindings_handle(&mut self, handle: EureBindingsHandle, tree: &F)
2402 -> Result<(), E>;
2403 fn visit_eure_bindings_super(
2404 &mut self,
2405 handle: EureBindingsHandle,
2406 view: EureBindingsView,
2407 tree: &F,
2408 ) -> Result<(), E>;
2409 fn visit_eure_sections_handle(&mut self, handle: EureSectionsHandle, tree: &F)
2410 -> Result<(), E>;
2411 fn visit_eure_sections_super(
2412 &mut self,
2413 handle: EureSectionsHandle,
2414 view: EureSectionsView,
2415 tree: &F,
2416 ) -> Result<(), E>;
2417 fn visit_eure_opt_handle(&mut self, handle: EureOptHandle, tree: &F) -> Result<(), E>;
2418 fn visit_eure_opt_super(
2419 &mut self,
2420 handle: EureOptHandle,
2421 view: TopLevelBindingHandle,
2422 tree: &F,
2423 ) -> Result<(), E>;
2424 fn visit_ext_handle(&mut self, handle: ExtHandle, tree: &F) -> Result<(), E>;
2425 fn visit_ext_super(&mut self, handle: ExtHandle, view: ExtView, tree: &F) -> Result<(), E>;
2426 fn visit_extension_name_space_handle(
2427 &mut self,
2428 handle: ExtensionNameSpaceHandle,
2429 tree: &F,
2430 ) -> Result<(), E>;
2431 fn visit_extension_name_space_super(
2432 &mut self,
2433 handle: ExtensionNameSpaceHandle,
2434 view: ExtensionNameSpaceView,
2435 tree: &F,
2436 ) -> Result<(), E>;
2437 fn visit_false_handle(&mut self, handle: FalseHandle, tree: &F) -> Result<(), E>;
2438 fn visit_false_super(
2439 &mut self,
2440 handle: FalseHandle,
2441 view: FalseView,
2442 tree: &F,
2443 ) -> Result<(), E>;
2444 fn visit_first_key_handle(&mut self, handle: FirstKeyHandle, tree: &F) -> Result<(), E>;
2445 fn visit_first_key_super(
2446 &mut self,
2447 handle: FirstKeyHandle,
2448 view: FirstKeyView,
2449 tree: &F,
2450 ) -> Result<(), E>;
2451 fn visit_flat_body_handle(&mut self, handle: FlatBodyHandle, tree: &F) -> Result<(), E>;
2452 fn visit_flat_body_super(
2453 &mut self,
2454 handle: FlatBodyHandle,
2455 view: FlatBodyView,
2456 tree: &F,
2457 ) -> Result<(), E>;
2458 fn visit_flat_body_list_handle(
2459 &mut self,
2460 handle: FlatBodyListHandle,
2461 tree: &F,
2462 ) -> Result<(), E>;
2463 fn visit_flat_body_list_super(
2464 &mut self,
2465 handle: FlatBodyListHandle,
2466 view: FlatBodyListView,
2467 tree: &F,
2468 ) -> Result<(), E>;
2469 fn visit_flat_root_binding_handle(
2470 &mut self,
2471 handle: FlatRootBindingHandle,
2472 tree: &F,
2473 ) -> Result<(), E>;
2474 fn visit_flat_root_binding_super(
2475 &mut self,
2476 handle: FlatRootBindingHandle,
2477 view: FlatRootBindingView,
2478 tree: &F,
2479 ) -> Result<(), E>;
2480 fn visit_float_handle(&mut self, handle: FloatHandle, tree: &F) -> Result<(), E>;
2481 fn visit_float_super(
2482 &mut self,
2483 handle: FloatHandle,
2484 view: FloatView,
2485 tree: &F,
2486 ) -> Result<(), E>;
2487 fn visit_grammar_newline_handle(
2488 &mut self,
2489 handle: GrammarNewlineHandle,
2490 tree: &F,
2491 ) -> Result<(), E>;
2492 fn visit_grammar_newline_super(
2493 &mut self,
2494 handle: GrammarNewlineHandle,
2495 view: GrammarNewlineView,
2496 tree: &F,
2497 ) -> Result<(), E>;
2498 fn visit_hole_handle(&mut self, handle: HoleHandle, tree: &F) -> Result<(), E>;
2499 fn visit_hole_super(&mut self, handle: HoleHandle, view: HoleView, tree: &F) -> Result<(), E>;
2500 fn visit_ident_handle(&mut self, handle: IdentHandle, tree: &F) -> Result<(), E>;
2501 fn visit_ident_super(
2502 &mut self,
2503 handle: IdentHandle,
2504 view: IdentView,
2505 tree: &F,
2506 ) -> Result<(), E>;
2507 fn visit_inf_handle(&mut self, handle: InfHandle, tree: &F) -> Result<(), E>;
2508 fn visit_inf_super(&mut self, handle: InfHandle, view: InfView, tree: &F) -> Result<(), E>;
2509 fn visit_inline_code_handle(&mut self, handle: InlineCodeHandle, tree: &F) -> Result<(), E>;
2510 fn visit_inline_code_super(
2511 &mut self,
2512 handle: InlineCodeHandle,
2513 view: InlineCodeView,
2514 tree: &F,
2515 ) -> Result<(), E>;
2516 fn visit_inline_code_1_handle(&mut self, handle: InlineCode1Handle, tree: &F) -> Result<(), E>;
2517 fn visit_inline_code_1_super(
2518 &mut self,
2519 handle: InlineCode1Handle,
2520 view: InlineCode1View,
2521 tree: &F,
2522 ) -> Result<(), E>;
2523 fn visit_integer_handle(&mut self, handle: IntegerHandle, tree: &F) -> Result<(), E>;
2524 fn visit_integer_super(
2525 &mut self,
2526 handle: IntegerHandle,
2527 view: IntegerView,
2528 tree: &F,
2529 ) -> Result<(), E>;
2530 fn visit_key_handle(&mut self, handle: KeyHandle, tree: &F) -> Result<(), E>;
2531 fn visit_key_super(&mut self, handle: KeyHandle, view: KeyView, tree: &F) -> Result<(), E>;
2532 fn visit_key_ident_handle(&mut self, handle: KeyIdentHandle, tree: &F) -> Result<(), E>;
2533 fn visit_key_ident_super(
2534 &mut self,
2535 handle: KeyIdentHandle,
2536 view: KeyIdentView,
2537 tree: &F,
2538 ) -> Result<(), E>;
2539 fn visit_key_tail_handle(&mut self, handle: KeyTailHandle, tree: &F) -> Result<(), E>;
2540 fn visit_key_tail_super(
2541 &mut self,
2542 handle: KeyTailHandle,
2543 view: KeyTailView,
2544 tree: &F,
2545 ) -> Result<(), E>;
2546 fn visit_key_tuple_handle(&mut self, handle: KeyTupleHandle, tree: &F) -> Result<(), E>;
2547 fn visit_key_tuple_super(
2548 &mut self,
2549 handle: KeyTupleHandle,
2550 view: KeyTupleView,
2551 tree: &F,
2552 ) -> Result<(), E>;
2553 fn visit_key_tuple_elements_handle(
2554 &mut self,
2555 handle: KeyTupleElementsHandle,
2556 tree: &F,
2557 ) -> Result<(), E>;
2558 fn visit_key_tuple_elements_super(
2559 &mut self,
2560 handle: KeyTupleElementsHandle,
2561 view: KeyTupleElementsView,
2562 tree: &F,
2563 ) -> Result<(), E>;
2564 fn visit_key_tuple_elements_opt_handle(
2565 &mut self,
2566 handle: KeyTupleElementsOptHandle,
2567 tree: &F,
2568 ) -> Result<(), E>;
2569 fn visit_key_tuple_elements_opt_super(
2570 &mut self,
2571 handle: KeyTupleElementsOptHandle,
2572 view: KeyTupleElementsTailHandle,
2573 tree: &F,
2574 ) -> Result<(), E>;
2575 fn visit_key_tuple_elements_tail_handle(
2576 &mut self,
2577 handle: KeyTupleElementsTailHandle,
2578 tree: &F,
2579 ) -> Result<(), E>;
2580 fn visit_key_tuple_elements_tail_super(
2581 &mut self,
2582 handle: KeyTupleElementsTailHandle,
2583 view: KeyTupleElementsTailView,
2584 tree: &F,
2585 ) -> Result<(), E>;
2586 fn visit_key_tuple_elements_tail_opt_handle(
2587 &mut self,
2588 handle: KeyTupleElementsTailOptHandle,
2589 tree: &F,
2590 ) -> Result<(), E>;
2591 fn visit_key_tuple_elements_tail_opt_super(
2592 &mut self,
2593 handle: KeyTupleElementsTailOptHandle,
2594 view: KeyTupleElementsHandle,
2595 tree: &F,
2596 ) -> Result<(), E>;
2597 fn visit_key_tuple_opt_handle(&mut self, handle: KeyTupleOptHandle, tree: &F) -> Result<(), E>;
2598 fn visit_key_tuple_opt_super(
2599 &mut self,
2600 handle: KeyTupleOptHandle,
2601 view: KeyTupleElementsHandle,
2602 tree: &F,
2603 ) -> Result<(), E>;
2604 fn visit_key_value_handle(&mut self, handle: KeyValueHandle, tree: &F) -> Result<(), E>;
2605 fn visit_key_value_super(
2606 &mut self,
2607 handle: KeyValueHandle,
2608 view: KeyValueView,
2609 tree: &F,
2610 ) -> Result<(), E>;
2611 fn visit_keys_handle(&mut self, handle: KeysHandle, tree: &F) -> Result<(), E>;
2612 fn visit_keys_super(&mut self, handle: KeysHandle, view: KeysView, tree: &F) -> Result<(), E>;
2613 fn visit_keys_list_handle(&mut self, handle: KeysListHandle, tree: &F) -> Result<(), E>;
2614 fn visit_keys_list_super(
2615 &mut self,
2616 handle: KeysListHandle,
2617 view: KeysListView,
2618 tree: &F,
2619 ) -> Result<(), E>;
2620 fn visit_l_paren_handle(&mut self, handle: LParenHandle, tree: &F) -> Result<(), E>;
2621 fn visit_l_paren_super(
2622 &mut self,
2623 handle: LParenHandle,
2624 view: LParenView,
2625 tree: &F,
2626 ) -> Result<(), E>;
2627 fn visit_lit_str_handle(&mut self, handle: LitStrHandle, tree: &F) -> Result<(), E>;
2628 fn visit_lit_str_super(
2629 &mut self,
2630 handle: LitStrHandle,
2631 view: LitStrView,
2632 tree: &F,
2633 ) -> Result<(), E>;
2634 fn visit_lit_str_1_handle(&mut self, handle: LitStr1Handle, tree: &F) -> Result<(), E>;
2635 fn visit_lit_str_1_super(
2636 &mut self,
2637 handle: LitStr1Handle,
2638 view: LitStr1View,
2639 tree: &F,
2640 ) -> Result<(), E>;
2641 fn visit_lit_str_1_end_handle(&mut self, handle: LitStr1EndHandle, tree: &F) -> Result<(), E>;
2642 fn visit_lit_str_1_end_super(
2643 &mut self,
2644 handle: LitStr1EndHandle,
2645 view: LitStr1EndView,
2646 tree: &F,
2647 ) -> Result<(), E>;
2648 fn visit_lit_str_1_list_handle(&mut self, handle: LitStr1ListHandle, tree: &F)
2649 -> Result<(), E>;
2650 fn visit_lit_str_1_list_super(
2651 &mut self,
2652 handle: LitStr1ListHandle,
2653 view: LitStr1ListView,
2654 tree: &F,
2655 ) -> Result<(), E>;
2656 fn visit_lit_str_1_list_group_handle(
2657 &mut self,
2658 handle: LitStr1ListGroupHandle,
2659 tree: &F,
2660 ) -> Result<(), E>;
2661 fn visit_lit_str_1_list_group_super(
2662 &mut self,
2663 handle: LitStr1ListGroupHandle,
2664 view: LitStr1ListGroupView,
2665 tree: &F,
2666 ) -> Result<(), E>;
2667 fn visit_lit_str_1_start_handle(
2668 &mut self,
2669 handle: LitStr1StartHandle,
2670 tree: &F,
2671 ) -> Result<(), E>;
2672 fn visit_lit_str_1_start_super(
2673 &mut self,
2674 handle: LitStr1StartHandle,
2675 view: LitStr1StartView,
2676 tree: &F,
2677 ) -> Result<(), E>;
2678 fn visit_lit_str_2_handle(&mut self, handle: LitStr2Handle, tree: &F) -> Result<(), E>;
2679 fn visit_lit_str_2_super(
2680 &mut self,
2681 handle: LitStr2Handle,
2682 view: LitStr2View,
2683 tree: &F,
2684 ) -> Result<(), E>;
2685 fn visit_lit_str_2_end_handle(&mut self, handle: LitStr2EndHandle, tree: &F) -> Result<(), E>;
2686 fn visit_lit_str_2_end_super(
2687 &mut self,
2688 handle: LitStr2EndHandle,
2689 view: LitStr2EndView,
2690 tree: &F,
2691 ) -> Result<(), E>;
2692 fn visit_lit_str_2_list_handle(&mut self, handle: LitStr2ListHandle, tree: &F)
2693 -> Result<(), E>;
2694 fn visit_lit_str_2_list_super(
2695 &mut self,
2696 handle: LitStr2ListHandle,
2697 view: LitStr2ListView,
2698 tree: &F,
2699 ) -> Result<(), E>;
2700 fn visit_lit_str_2_list_group_handle(
2701 &mut self,
2702 handle: LitStr2ListGroupHandle,
2703 tree: &F,
2704 ) -> Result<(), E>;
2705 fn visit_lit_str_2_list_group_super(
2706 &mut self,
2707 handle: LitStr2ListGroupHandle,
2708 view: LitStr2ListGroupView,
2709 tree: &F,
2710 ) -> Result<(), E>;
2711 fn visit_lit_str_2_start_handle(
2712 &mut self,
2713 handle: LitStr2StartHandle,
2714 tree: &F,
2715 ) -> Result<(), E>;
2716 fn visit_lit_str_2_start_super(
2717 &mut self,
2718 handle: LitStr2StartHandle,
2719 view: LitStr2StartView,
2720 tree: &F,
2721 ) -> Result<(), E>;
2722 fn visit_lit_str_3_handle(&mut self, handle: LitStr3Handle, tree: &F) -> Result<(), E>;
2723 fn visit_lit_str_3_super(
2724 &mut self,
2725 handle: LitStr3Handle,
2726 view: LitStr3View,
2727 tree: &F,
2728 ) -> Result<(), E>;
2729 fn visit_lit_str_3_end_handle(&mut self, handle: LitStr3EndHandle, tree: &F) -> Result<(), E>;
2730 fn visit_lit_str_3_end_super(
2731 &mut self,
2732 handle: LitStr3EndHandle,
2733 view: LitStr3EndView,
2734 tree: &F,
2735 ) -> Result<(), E>;
2736 fn visit_lit_str_3_list_handle(&mut self, handle: LitStr3ListHandle, tree: &F)
2737 -> Result<(), E>;
2738 fn visit_lit_str_3_list_super(
2739 &mut self,
2740 handle: LitStr3ListHandle,
2741 view: LitStr3ListView,
2742 tree: &F,
2743 ) -> Result<(), E>;
2744 fn visit_lit_str_3_list_group_handle(
2745 &mut self,
2746 handle: LitStr3ListGroupHandle,
2747 tree: &F,
2748 ) -> Result<(), E>;
2749 fn visit_lit_str_3_list_group_super(
2750 &mut self,
2751 handle: LitStr3ListGroupHandle,
2752 view: LitStr3ListGroupView,
2753 tree: &F,
2754 ) -> Result<(), E>;
2755 fn visit_lit_str_3_start_handle(
2756 &mut self,
2757 handle: LitStr3StartHandle,
2758 tree: &F,
2759 ) -> Result<(), E>;
2760 fn visit_lit_str_3_start_super(
2761 &mut self,
2762 handle: LitStr3StartHandle,
2763 view: LitStr3StartView,
2764 tree: &F,
2765 ) -> Result<(), E>;
2766 fn visit_map_bind_handle(&mut self, handle: MapBindHandle, tree: &F) -> Result<(), E>;
2767 fn visit_map_bind_super(
2768 &mut self,
2769 handle: MapBindHandle,
2770 view: MapBindView,
2771 tree: &F,
2772 ) -> Result<(), E>;
2773 fn visit_na_n_handle(&mut self, handle: NaNHandle, tree: &F) -> Result<(), E>;
2774 fn visit_na_n_super(&mut self, handle: NaNHandle, view: NaNView, tree: &F) -> Result<(), E>;
2775 fn visit_newline_bind_handle(&mut self, handle: NewlineBindHandle, tree: &F) -> Result<(), E>;
2776 fn visit_newline_bind_super(
2777 &mut self,
2778 handle: NewlineBindHandle,
2779 view: NewlineBindView,
2780 tree: &F,
2781 ) -> Result<(), E>;
2782 fn visit_newline_head_handle(&mut self, handle: NewlineHeadHandle, tree: &F) -> Result<(), E>;
2783 fn visit_newline_head_super(
2784 &mut self,
2785 handle: NewlineHeadHandle,
2786 view: NewlineHeadView,
2787 tree: &F,
2788 ) -> Result<(), E>;
2789 fn visit_newline_head_opt_handle(
2790 &mut self,
2791 handle: NewlineHeadOptHandle,
2792 tree: &F,
2793 ) -> Result<(), E>;
2794 fn visit_newline_head_opt_super(
2795 &mut self,
2796 handle: NewlineHeadOptHandle,
2797 view: FlatRootBindingHandle,
2798 tree: &F,
2799 ) -> Result<(), E>;
2800 fn visit_newline_text_start_handle(
2801 &mut self,
2802 handle: NewlineTextStartHandle,
2803 tree: &F,
2804 ) -> Result<(), E>;
2805 fn visit_newline_text_start_super(
2806 &mut self,
2807 handle: NewlineTextStartHandle,
2808 view: NewlineTextStartView,
2809 tree: &F,
2810 ) -> Result<(), E>;
2811 fn visit_no_backtick_handle(&mut self, handle: NoBacktickHandle, tree: &F) -> Result<(), E>;
2812 fn visit_no_backtick_super(
2813 &mut self,
2814 handle: NoBacktickHandle,
2815 view: NoBacktickView,
2816 tree: &F,
2817 ) -> Result<(), E>;
2818 fn visit_no_s_quote_handle(&mut self, handle: NoSQuoteHandle, tree: &F) -> Result<(), E>;
2819 fn visit_no_s_quote_super(
2820 &mut self,
2821 handle: NoSQuoteHandle,
2822 view: NoSQuoteView,
2823 tree: &F,
2824 ) -> Result<(), E>;
2825 fn visit_null_handle(&mut self, handle: NullHandle, tree: &F) -> Result<(), E>;
2826 fn visit_null_super(&mut self, handle: NullHandle, view: NullView, tree: &F) -> Result<(), E>;
2827 fn visit_number_handle(&mut self, handle: NumberHandle, tree: &F) -> Result<(), E>;
2828 fn visit_number_super(
2829 &mut self,
2830 handle: NumberHandle,
2831 view: NumberView,
2832 tree: &F,
2833 ) -> Result<(), E>;
2834 fn visit_object_handle(&mut self, handle: ObjectHandle, tree: &F) -> Result<(), E>;
2835 fn visit_object_super(
2836 &mut self,
2837 handle: ObjectHandle,
2838 view: ObjectView,
2839 tree: &F,
2840 ) -> Result<(), E>;
2841 fn visit_object_list_handle(&mut self, handle: ObjectListHandle, tree: &F) -> Result<(), E>;
2842 fn visit_object_list_super(
2843 &mut self,
2844 handle: ObjectListHandle,
2845 view: ObjectListView,
2846 tree: &F,
2847 ) -> Result<(), E>;
2848 fn visit_object_opt_handle(&mut self, handle: ObjectOptHandle, tree: &F) -> Result<(), E>;
2849 fn visit_object_opt_super(
2850 &mut self,
2851 handle: ObjectOptHandle,
2852 view: ObjectOptView,
2853 tree: &F,
2854 ) -> Result<(), E>;
2855 fn visit_object_opt_0_handle(&mut self, handle: ObjectOpt0Handle, tree: &F) -> Result<(), E>;
2856 fn visit_object_opt_0_super(
2857 &mut self,
2858 handle: ObjectOpt0Handle,
2859 view: CommaHandle,
2860 tree: &F,
2861 ) -> Result<(), E>;
2862 fn visit_object_opt_1_handle(&mut self, handle: ObjectOpt1Handle, tree: &F) -> Result<(), E>;
2863 fn visit_object_opt_1_super(
2864 &mut self,
2865 handle: ObjectOpt1Handle,
2866 view: CommaHandle,
2867 tree: &F,
2868 ) -> Result<(), E>;
2869 fn visit_r_paren_handle(&mut self, handle: RParenHandle, tree: &F) -> Result<(), E>;
2870 fn visit_r_paren_super(
2871 &mut self,
2872 handle: RParenHandle,
2873 view: RParenView,
2874 tree: &F,
2875 ) -> Result<(), E>;
2876 fn visit_root_binding_handle(&mut self, handle: RootBindingHandle, tree: &F) -> Result<(), E>;
2877 fn visit_root_binding_super(
2878 &mut self,
2879 handle: RootBindingHandle,
2880 view: RootBindingView,
2881 tree: &F,
2882 ) -> Result<(), E>;
2883 fn visit_root_text_binding_handle(
2884 &mut self,
2885 handle: RootTextBindingHandle,
2886 tree: &F,
2887 ) -> Result<(), E>;
2888 fn visit_root_text_binding_super(
2889 &mut self,
2890 handle: RootTextBindingHandle,
2891 view: RootTextBindingView,
2892 tree: &F,
2893 ) -> Result<(), E>;
2894 fn visit_root_text_binding_opt_handle(
2895 &mut self,
2896 handle: RootTextBindingOptHandle,
2897 tree: &F,
2898 ) -> Result<(), E>;
2899 fn visit_root_text_binding_opt_super(
2900 &mut self,
2901 handle: RootTextBindingOptHandle,
2902 view: WsHandle,
2903 tree: &F,
2904 ) -> Result<(), E>;
2905 fn visit_root_text_binding_opt_0_handle(
2906 &mut self,
2907 handle: RootTextBindingOpt0Handle,
2908 tree: &F,
2909 ) -> Result<(), E>;
2910 fn visit_root_text_binding_opt_0_super(
2911 &mut self,
2912 handle: RootTextBindingOpt0Handle,
2913 view: TextHandle,
2914 tree: &F,
2915 ) -> Result<(), E>;
2916 fn visit_root_text_binding_opt_1_handle(
2917 &mut self,
2918 handle: RootTextBindingOpt1Handle,
2919 tree: &F,
2920 ) -> Result<(), E>;
2921 fn visit_root_text_binding_opt_1_super(
2922 &mut self,
2923 handle: RootTextBindingOpt1Handle,
2924 view: GrammarNewlineHandle,
2925 tree: &F,
2926 ) -> Result<(), E>;
2927 fn visit_root_value_binding_handle(
2928 &mut self,
2929 handle: RootValueBindingHandle,
2930 tree: &F,
2931 ) -> Result<(), E>;
2932 fn visit_root_value_binding_super(
2933 &mut self,
2934 handle: RootValueBindingHandle,
2935 view: RootValueBindingView,
2936 tree: &F,
2937 ) -> Result<(), E>;
2938 fn visit_s_quote_handle(&mut self, handle: SQuoteHandle, tree: &F) -> Result<(), E>;
2939 fn visit_s_quote_super(
2940 &mut self,
2941 handle: SQuoteHandle,
2942 view: SQuoteView,
2943 tree: &F,
2944 ) -> Result<(), E>;
2945 fn visit_section_handle(&mut self, handle: SectionHandle, tree: &F) -> Result<(), E>;
2946 fn visit_section_super(
2947 &mut self,
2948 handle: SectionHandle,
2949 view: SectionView,
2950 tree: &F,
2951 ) -> Result<(), E>;
2952 fn visit_section_binding_handle(
2953 &mut self,
2954 handle: SectionBindingHandle,
2955 tree: &F,
2956 ) -> Result<(), E>;
2957 fn visit_section_binding_super(
2958 &mut self,
2959 handle: SectionBindingHandle,
2960 view: SectionBindingView,
2961 tree: &F,
2962 ) -> Result<(), E>;
2963 fn visit_section_body_handle(&mut self, handle: SectionBodyHandle, tree: &F) -> Result<(), E>;
2964 fn visit_section_body_super(
2965 &mut self,
2966 handle: SectionBodyHandle,
2967 view: SectionBodyView,
2968 tree: &F,
2969 ) -> Result<(), E>;
2970 fn visit_section_body_opt_handle(
2971 &mut self,
2972 handle: SectionBodyOptHandle,
2973 tree: &F,
2974 ) -> Result<(), E>;
2975 fn visit_section_body_opt_super(
2976 &mut self,
2977 handle: SectionBodyOptHandle,
2978 view: FlatBodyHandle,
2979 tree: &F,
2980 ) -> Result<(), E>;
2981 fn visit_section_head_handle(&mut self, handle: SectionHeadHandle, tree: &F) -> Result<(), E>;
2982 fn visit_section_head_super(
2983 &mut self,
2984 handle: SectionHeadHandle,
2985 view: SectionHeadView,
2986 tree: &F,
2987 ) -> Result<(), E>;
2988 fn visit_str_handle(&mut self, handle: StrHandle, tree: &F) -> Result<(), E>;
2989 fn visit_str_super(&mut self, handle: StrHandle, view: StrView, tree: &F) -> Result<(), E>;
2990 fn visit_string_handle(&mut self, handle: StringHandle, tree: &F) -> Result<(), E>;
2991 fn visit_string_super(
2992 &mut self,
2993 handle: StringHandle,
2994 view: StringView,
2995 tree: &F,
2996 ) -> Result<(), E>;
2997 fn visit_strings_handle(&mut self, handle: StringsHandle, tree: &F) -> Result<(), E>;
2998 fn visit_strings_super(
2999 &mut self,
3000 handle: StringsHandle,
3001 view: StringsView,
3002 tree: &F,
3003 ) -> Result<(), E>;
3004 fn visit_strings_list_handle(&mut self, handle: StringsListHandle, tree: &F) -> Result<(), E>;
3005 fn visit_strings_list_super(
3006 &mut self,
3007 handle: StringsListHandle,
3008 view: StringsListView,
3009 tree: &F,
3010 ) -> Result<(), E>;
3011 fn visit_text_handle(&mut self, handle: TextHandle, tree: &F) -> Result<(), E>;
3012 fn visit_text_super(&mut self, handle: TextHandle, view: TextView, tree: &F) -> Result<(), E>;
3013 fn visit_text_binding_handle(&mut self, handle: TextBindingHandle, tree: &F) -> Result<(), E>;
3014 fn visit_text_binding_super(
3015 &mut self,
3016 handle: TextBindingHandle,
3017 view: TextBindingView,
3018 tree: &F,
3019 ) -> Result<(), E>;
3020 fn visit_text_binding_opt_handle(
3021 &mut self,
3022 handle: TextBindingOptHandle,
3023 tree: &F,
3024 ) -> Result<(), E>;
3025 fn visit_text_binding_opt_super(
3026 &mut self,
3027 handle: TextBindingOptHandle,
3028 view: WsHandle,
3029 tree: &F,
3030 ) -> Result<(), E>;
3031 fn visit_text_binding_opt_0_handle(
3032 &mut self,
3033 handle: TextBindingOpt0Handle,
3034 tree: &F,
3035 ) -> Result<(), E>;
3036 fn visit_text_binding_opt_0_super(
3037 &mut self,
3038 handle: TextBindingOpt0Handle,
3039 view: TextHandle,
3040 tree: &F,
3041 ) -> Result<(), E>;
3042 fn visit_text_binding_opt_1_handle(
3043 &mut self,
3044 handle: TextBindingOpt1Handle,
3045 tree: &F,
3046 ) -> Result<(), E>;
3047 fn visit_text_binding_opt_1_super(
3048 &mut self,
3049 handle: TextBindingOpt1Handle,
3050 view: GrammarNewlineHandle,
3051 tree: &F,
3052 ) -> Result<(), E>;
3053 fn visit_text_start_handle(&mut self, handle: TextStartHandle, tree: &F) -> Result<(), E>;
3054 fn visit_text_start_super(
3055 &mut self,
3056 handle: TextStartHandle,
3057 view: TextStartView,
3058 tree: &F,
3059 ) -> Result<(), E>;
3060 fn visit_top_level_binding_handle(
3061 &mut self,
3062 handle: TopLevelBindingHandle,
3063 tree: &F,
3064 ) -> Result<(), E>;
3065 fn visit_top_level_binding_super(
3066 &mut self,
3067 handle: TopLevelBindingHandle,
3068 view: TopLevelBindingView,
3069 tree: &F,
3070 ) -> Result<(), E>;
3071 fn visit_true_handle(&mut self, handle: TrueHandle, tree: &F) -> Result<(), E>;
3072 fn visit_true_super(&mut self, handle: TrueHandle, view: TrueView, tree: &F) -> Result<(), E>;
3073 fn visit_tuple_handle(&mut self, handle: TupleHandle, tree: &F) -> Result<(), E>;
3074 fn visit_tuple_super(
3075 &mut self,
3076 handle: TupleHandle,
3077 view: TupleView,
3078 tree: &F,
3079 ) -> Result<(), E>;
3080 fn visit_tuple_elements_handle(
3081 &mut self,
3082 handle: TupleElementsHandle,
3083 tree: &F,
3084 ) -> Result<(), E>;
3085 fn visit_tuple_elements_super(
3086 &mut self,
3087 handle: TupleElementsHandle,
3088 view: TupleElementsView,
3089 tree: &F,
3090 ) -> Result<(), E>;
3091 fn visit_tuple_elements_opt_handle(
3092 &mut self,
3093 handle: TupleElementsOptHandle,
3094 tree: &F,
3095 ) -> Result<(), E>;
3096 fn visit_tuple_elements_opt_super(
3097 &mut self,
3098 handle: TupleElementsOptHandle,
3099 view: TupleElementsTailHandle,
3100 tree: &F,
3101 ) -> Result<(), E>;
3102 fn visit_tuple_elements_tail_handle(
3103 &mut self,
3104 handle: TupleElementsTailHandle,
3105 tree: &F,
3106 ) -> Result<(), E>;
3107 fn visit_tuple_elements_tail_super(
3108 &mut self,
3109 handle: TupleElementsTailHandle,
3110 view: TupleElementsTailView,
3111 tree: &F,
3112 ) -> Result<(), E>;
3113 fn visit_tuple_elements_tail_opt_handle(
3114 &mut self,
3115 handle: TupleElementsTailOptHandle,
3116 tree: &F,
3117 ) -> Result<(), E>;
3118 fn visit_tuple_elements_tail_opt_super(
3119 &mut self,
3120 handle: TupleElementsTailOptHandle,
3121 view: TupleElementsHandle,
3122 tree: &F,
3123 ) -> Result<(), E>;
3124 fn visit_tuple_index_handle(&mut self, handle: TupleIndexHandle, tree: &F) -> Result<(), E>;
3125 fn visit_tuple_index_super(
3126 &mut self,
3127 handle: TupleIndexHandle,
3128 view: TupleIndexView,
3129 tree: &F,
3130 ) -> Result<(), E>;
3131 fn visit_tuple_opt_handle(&mut self, handle: TupleOptHandle, tree: &F) -> Result<(), E>;
3132 fn visit_tuple_opt_super(
3133 &mut self,
3134 handle: TupleOptHandle,
3135 view: TupleElementsHandle,
3136 tree: &F,
3137 ) -> Result<(), E>;
3138 fn visit_value_handle(&mut self, handle: ValueHandle, tree: &F) -> Result<(), E>;
3139 fn visit_value_super(
3140 &mut self,
3141 handle: ValueHandle,
3142 view: ValueView,
3143 tree: &F,
3144 ) -> Result<(), E>;
3145 fn visit_value_binding_handle(&mut self, handle: ValueBindingHandle, tree: &F)
3146 -> Result<(), E>;
3147 fn visit_value_binding_super(
3148 &mut self,
3149 handle: ValueBindingHandle,
3150 view: ValueBindingView,
3151 tree: &F,
3152 ) -> Result<(), E>;
3153 fn visit_ws_handle(&mut self, handle: WsHandle, tree: &F) -> Result<(), E>;
3154 fn visit_ws_super(&mut self, handle: WsHandle, view: WsView, tree: &F) -> Result<(), E>;
3155 fn visit_root_handle(&mut self, handle: RootHandle, tree: &F) -> Result<(), E>;
3156 fn visit_root_super(&mut self, handle: RootHandle, view: RootView, tree: &F) -> Result<(), E>;
3157 fn visit_new_line_terminal_super(
3158 &mut self,
3159 terminal: NewLine,
3160 data: TerminalData,
3161 tree: &F,
3162 ) -> Result<(), E>;
3163 fn visit_whitespace_terminal_super(
3164 &mut self,
3165 terminal: Whitespace,
3166 data: TerminalData,
3167 tree: &F,
3168 ) -> Result<(), E>;
3169 fn visit_line_comment_terminal_super(
3170 &mut self,
3171 terminal: LineComment,
3172 data: TerminalData,
3173 tree: &F,
3174 ) -> Result<(), E>;
3175 fn visit_block_comment_terminal_super(
3176 &mut self,
3177 terminal: BlockComment,
3178 data: TerminalData,
3179 tree: &F,
3180 ) -> Result<(), E>;
3181 fn visit_hash_terminal_super(
3182 &mut self,
3183 terminal: Hash,
3184 data: TerminalData,
3185 tree: &F,
3186 ) -> Result<(), E>;
3187 fn visit_map_bind_terminal_super(
3188 &mut self,
3189 terminal: MapBind,
3190 data: TerminalData,
3191 tree: &F,
3192 ) -> Result<(), E>;
3193 fn visit_integer_terminal_super(
3194 &mut self,
3195 terminal: Integer,
3196 data: TerminalData,
3197 tree: &F,
3198 ) -> Result<(), E>;
3199 fn visit_float_terminal_super(
3200 &mut self,
3201 terminal: Float,
3202 data: TerminalData,
3203 tree: &F,
3204 ) -> Result<(), E>;
3205 fn visit_inf_terminal_super(
3206 &mut self,
3207 terminal: Inf,
3208 data: TerminalData,
3209 tree: &F,
3210 ) -> Result<(), E>;
3211 fn visit_na_n_terminal_super(
3212 &mut self,
3213 terminal: NaN,
3214 data: TerminalData,
3215 tree: &F,
3216 ) -> Result<(), E>;
3217 fn visit_true_terminal_super(
3218 &mut self,
3219 terminal: True,
3220 data: TerminalData,
3221 tree: &F,
3222 ) -> Result<(), E>;
3223 fn visit_false_terminal_super(
3224 &mut self,
3225 terminal: False,
3226 data: TerminalData,
3227 tree: &F,
3228 ) -> Result<(), E>;
3229 fn visit_null_terminal_super(
3230 &mut self,
3231 terminal: Null,
3232 data: TerminalData,
3233 tree: &F,
3234 ) -> Result<(), E>;
3235 fn visit_hole_terminal_super(
3236 &mut self,
3237 terminal: Hole,
3238 data: TerminalData,
3239 tree: &F,
3240 ) -> Result<(), E>;
3241 fn visit_str_terminal_super(
3242 &mut self,
3243 terminal: Str,
3244 data: TerminalData,
3245 tree: &F,
3246 ) -> Result<(), E>;
3247 fn visit_lit_str_terminal_super(
3248 &mut self,
3249 terminal: LitStr,
3250 data: TerminalData,
3251 tree: &F,
3252 ) -> Result<(), E>;
3253 fn visit_text_terminal_super(
3254 &mut self,
3255 terminal: Text,
3256 data: TerminalData,
3257 tree: &F,
3258 ) -> Result<(), E>;
3259 fn visit_inline_code_1_terminal_super(
3260 &mut self,
3261 terminal: InlineCode1,
3262 data: TerminalData,
3263 tree: &F,
3264 ) -> Result<(), E>;
3265 fn visit_lit_str_3_start_terminal_super(
3266 &mut self,
3267 terminal: LitStr3Start,
3268 data: TerminalData,
3269 tree: &F,
3270 ) -> Result<(), E>;
3271 fn visit_lit_str_2_start_terminal_super(
3272 &mut self,
3273 terminal: LitStr2Start,
3274 data: TerminalData,
3275 tree: &F,
3276 ) -> Result<(), E>;
3277 fn visit_lit_str_1_start_terminal_super(
3278 &mut self,
3279 terminal: LitStr1Start,
3280 data: TerminalData,
3281 tree: &F,
3282 ) -> Result<(), E>;
3283 fn visit_delim_code_start_3_terminal_super(
3284 &mut self,
3285 terminal: DelimCodeStart3,
3286 data: TerminalData,
3287 tree: &F,
3288 ) -> Result<(), E>;
3289 fn visit_delim_code_start_2_terminal_super(
3290 &mut self,
3291 terminal: DelimCodeStart2,
3292 data: TerminalData,
3293 tree: &F,
3294 ) -> Result<(), E>;
3295 fn visit_delim_code_start_1_terminal_super(
3296 &mut self,
3297 terminal: DelimCodeStart1,
3298 data: TerminalData,
3299 tree: &F,
3300 ) -> Result<(), E>;
3301 fn visit_code_block_start_3_terminal_super(
3302 &mut self,
3303 terminal: CodeBlockStart3,
3304 data: TerminalData,
3305 tree: &F,
3306 ) -> Result<(), E>;
3307 fn visit_code_block_start_4_terminal_super(
3308 &mut self,
3309 terminal: CodeBlockStart4,
3310 data: TerminalData,
3311 tree: &F,
3312 ) -> Result<(), E>;
3313 fn visit_code_block_start_5_terminal_super(
3314 &mut self,
3315 terminal: CodeBlockStart5,
3316 data: TerminalData,
3317 tree: &F,
3318 ) -> Result<(), E>;
3319 fn visit_code_block_start_6_terminal_super(
3320 &mut self,
3321 terminal: CodeBlockStart6,
3322 data: TerminalData,
3323 tree: &F,
3324 ) -> Result<(), E>;
3325 fn visit_code_block_end_3_terminal_super(
3326 &mut self,
3327 terminal: CodeBlockEnd3,
3328 data: TerminalData,
3329 tree: &F,
3330 ) -> Result<(), E>;
3331 fn visit_backtick_2_terminal_super(
3332 &mut self,
3333 terminal: Backtick2,
3334 data: TerminalData,
3335 tree: &F,
3336 ) -> Result<(), E>;
3337 fn visit_code_block_end_4_terminal_super(
3338 &mut self,
3339 terminal: CodeBlockEnd4,
3340 data: TerminalData,
3341 tree: &F,
3342 ) -> Result<(), E>;
3343 fn visit_backtick_3_terminal_super(
3344 &mut self,
3345 terminal: Backtick3,
3346 data: TerminalData,
3347 tree: &F,
3348 ) -> Result<(), E>;
3349 fn visit_code_block_end_5_terminal_super(
3350 &mut self,
3351 terminal: CodeBlockEnd5,
3352 data: TerminalData,
3353 tree: &F,
3354 ) -> Result<(), E>;
3355 fn visit_backtick_4_terminal_super(
3356 &mut self,
3357 terminal: Backtick4,
3358 data: TerminalData,
3359 tree: &F,
3360 ) -> Result<(), E>;
3361 fn visit_code_block_end_6_terminal_super(
3362 &mut self,
3363 terminal: CodeBlockEnd6,
3364 data: TerminalData,
3365 tree: &F,
3366 ) -> Result<(), E>;
3367 fn visit_backtick_5_terminal_super(
3368 &mut self,
3369 terminal: Backtick5,
3370 data: TerminalData,
3371 tree: &F,
3372 ) -> Result<(), E>;
3373 fn visit_no_backtick_terminal_super(
3374 &mut self,
3375 terminal: NoBacktick,
3376 data: TerminalData,
3377 tree: &F,
3378 ) -> Result<(), E>;
3379 fn visit_lit_str_3_end_terminal_super(
3380 &mut self,
3381 terminal: LitStr3End,
3382 data: TerminalData,
3383 tree: &F,
3384 ) -> Result<(), E>;
3385 fn visit_lit_str_2_end_terminal_super(
3386 &mut self,
3387 terminal: LitStr2End,
3388 data: TerminalData,
3389 tree: &F,
3390 ) -> Result<(), E>;
3391 fn visit_lit_str_1_end_terminal_super(
3392 &mut self,
3393 terminal: LitStr1End,
3394 data: TerminalData,
3395 tree: &F,
3396 ) -> Result<(), E>;
3397 fn visit_s_quote_terminal_super(
3398 &mut self,
3399 terminal: SQuote,
3400 data: TerminalData,
3401 tree: &F,
3402 ) -> Result<(), E>;
3403 fn visit_no_s_quote_terminal_super(
3404 &mut self,
3405 terminal: NoSQuote,
3406 data: TerminalData,
3407 tree: &F,
3408 ) -> Result<(), E>;
3409 fn visit_delim_code_end_3_terminal_super(
3410 &mut self,
3411 terminal: DelimCodeEnd3,
3412 data: TerminalData,
3413 tree: &F,
3414 ) -> Result<(), E>;
3415 fn visit_delim_code_end_2_terminal_super(
3416 &mut self,
3417 terminal: DelimCodeEnd2,
3418 data: TerminalData,
3419 tree: &F,
3420 ) -> Result<(), E>;
3421 fn visit_delim_code_end_1_terminal_super(
3422 &mut self,
3423 terminal: DelimCodeEnd1,
3424 data: TerminalData,
3425 tree: &F,
3426 ) -> Result<(), E>;
3427 fn visit_backtick_delim_terminal_super(
3428 &mut self,
3429 terminal: BacktickDelim,
3430 data: TerminalData,
3431 tree: &F,
3432 ) -> Result<(), E>;
3433 fn visit_grammar_newline_terminal_super(
3434 &mut self,
3435 terminal: GrammarNewline,
3436 data: TerminalData,
3437 tree: &F,
3438 ) -> Result<(), E>;
3439 fn visit_ws_terminal_super(
3440 &mut self,
3441 terminal: Ws,
3442 data: TerminalData,
3443 tree: &F,
3444 ) -> Result<(), E>;
3445 fn visit_at_terminal_super(
3446 &mut self,
3447 terminal: At,
3448 data: TerminalData,
3449 tree: &F,
3450 ) -> Result<(), E>;
3451 fn visit_dollar_terminal_super(
3452 &mut self,
3453 terminal: Dollar,
3454 data: TerminalData,
3455 tree: &F,
3456 ) -> Result<(), E>;
3457 fn visit_dot_terminal_super(
3458 &mut self,
3459 terminal: Dot,
3460 data: TerminalData,
3461 tree: &F,
3462 ) -> Result<(), E>;
3463 fn visit_l_brace_terminal_super(
3464 &mut self,
3465 terminal: LBrace,
3466 data: TerminalData,
3467 tree: &F,
3468 ) -> Result<(), E>;
3469 fn visit_r_brace_terminal_super(
3470 &mut self,
3471 terminal: RBrace,
3472 data: TerminalData,
3473 tree: &F,
3474 ) -> Result<(), E>;
3475 fn visit_l_bracket_terminal_super(
3476 &mut self,
3477 terminal: LBracket,
3478 data: TerminalData,
3479 tree: &F,
3480 ) -> Result<(), E>;
3481 fn visit_r_bracket_terminal_super(
3482 &mut self,
3483 terminal: RBracket,
3484 data: TerminalData,
3485 tree: &F,
3486 ) -> Result<(), E>;
3487 fn visit_l_paren_terminal_super(
3488 &mut self,
3489 terminal: LParen,
3490 data: TerminalData,
3491 tree: &F,
3492 ) -> Result<(), E>;
3493 fn visit_r_paren_terminal_super(
3494 &mut self,
3495 terminal: RParen,
3496 data: TerminalData,
3497 tree: &F,
3498 ) -> Result<(), E>;
3499 fn visit_newline_bind_terminal_super(
3500 &mut self,
3501 terminal: NewlineBind,
3502 data: TerminalData,
3503 tree: &F,
3504 ) -> Result<(), E>;
3505 fn visit_bind_terminal_super(
3506 &mut self,
3507 terminal: Bind,
3508 data: TerminalData,
3509 tree: &F,
3510 ) -> Result<(), E>;
3511 fn visit_comma_terminal_super(
3512 &mut self,
3513 terminal: Comma,
3514 data: TerminalData,
3515 tree: &F,
3516 ) -> Result<(), E>;
3517 fn visit_esc_terminal_super(
3518 &mut self,
3519 terminal: Esc,
3520 data: TerminalData,
3521 tree: &F,
3522 ) -> Result<(), E>;
3523 fn visit_newline_text_start_terminal_super(
3524 &mut self,
3525 terminal: NewlineTextStart,
3526 data: TerminalData,
3527 tree: &F,
3528 ) -> Result<(), E>;
3529 fn visit_text_start_terminal_super(
3530 &mut self,
3531 terminal: TextStart,
3532 data: TerminalData,
3533 tree: &F,
3534 ) -> Result<(), E>;
3535 fn visit_ident_terminal_super(
3536 &mut self,
3537 terminal: Ident,
3538 data: TerminalData,
3539 tree: &F,
3540 ) -> Result<(), E>;
3541 fn visit_non_terminal_super(
3542 &mut self,
3543 id: CstNodeId,
3544 kind: NonTerminalKind,
3545 data: NonTerminalData,
3546 tree: &F,
3547 ) -> Result<(), E>;
3548 fn visit_non_terminal_close_super(
3549 &mut self,
3550 id: CstNodeId,
3551 kind: NonTerminalKind,
3552 data: NonTerminalData,
3553 tree: &F,
3554 ) -> Result<(), E>;
3555 fn visit_terminal_super(
3556 &mut self,
3557 id: CstNodeId,
3558 kind: TerminalKind,
3559 data: TerminalData,
3560 tree: &F,
3561 ) -> Result<(), E>;
3562 fn visit_any(&mut self, id: CstNodeId, node: CstNode, tree: &F) -> Result<(), E>;
3563 fn recover_error(
3565 &mut self,
3566 node_data: Option<CstNode>,
3567 id: CstNodeId,
3568 kind: NodeKind,
3569 tree: &F,
3570 ) -> Result<(), E>;
3571}
3572impl<V: CstVisitor<F>, F: CstFacade> private::Sealed<F> for V {}
3573impl<V: CstVisitor<F>, F: CstFacade> CstVisitorSuper<F, V::Error> for V {
3574 fn visit_array_handle(&mut self, handle: ArrayHandle, tree: &F) -> Result<(), V::Error> {
3575 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3576 Ok(nt_data) => nt_data,
3577 Err(error) => {
3578 return self.then_construct_error(
3579 None,
3580 handle.node_id(),
3581 NodeKind::NonTerminal(handle.kind()),
3582 error,
3583 tree,
3584 );
3585 }
3586 };
3587 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3588 let result = match handle
3589 .get_view_with_visit(
3590 tree,
3591 |view, visit: &mut Self| (visit.visit_array(handle, view, tree), visit),
3592 self,
3593 )
3594 .map_err(|e| e.extract_error())
3595 {
3596 Ok(Ok(())) => Ok(()),
3597 Ok(Err(e)) => Err(e),
3598 Err(Ok(e)) => Err(e),
3599 Err(Err(e)) => self.then_construct_error(
3600 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3601 handle.node_id(),
3602 NodeKind::NonTerminal(handle.kind()),
3603 e,
3604 tree,
3605 ),
3606 };
3607 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3608 result
3609 }
3610 fn visit_array_begin_handle(
3611 &mut self,
3612 handle: ArrayBeginHandle,
3613 tree: &F,
3614 ) -> Result<(), V::Error> {
3615 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3616 Ok(nt_data) => nt_data,
3617 Err(error) => {
3618 return self.then_construct_error(
3619 None,
3620 handle.node_id(),
3621 NodeKind::NonTerminal(handle.kind()),
3622 error,
3623 tree,
3624 );
3625 }
3626 };
3627 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3628 let result = match handle
3629 .get_view_with_visit(
3630 tree,
3631 |view, visit: &mut Self| (visit.visit_array_begin(handle, view, tree), visit),
3632 self,
3633 )
3634 .map_err(|e| e.extract_error())
3635 {
3636 Ok(Ok(())) => Ok(()),
3637 Ok(Err(e)) => Err(e),
3638 Err(Ok(e)) => Err(e),
3639 Err(Err(e)) => self.then_construct_error(
3640 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3641 handle.node_id(),
3642 NodeKind::NonTerminal(handle.kind()),
3643 e,
3644 tree,
3645 ),
3646 };
3647 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3648 result
3649 }
3650 fn visit_array_elements_handle(
3651 &mut self,
3652 handle: ArrayElementsHandle,
3653 tree: &F,
3654 ) -> Result<(), V::Error> {
3655 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3656 Ok(nt_data) => nt_data,
3657 Err(error) => {
3658 return self.then_construct_error(
3659 None,
3660 handle.node_id(),
3661 NodeKind::NonTerminal(handle.kind()),
3662 error,
3663 tree,
3664 );
3665 }
3666 };
3667 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3668 let result = match handle
3669 .get_view_with_visit(
3670 tree,
3671 |view, visit: &mut Self| (visit.visit_array_elements(handle, view, tree), visit),
3672 self,
3673 )
3674 .map_err(|e| e.extract_error())
3675 {
3676 Ok(Ok(())) => Ok(()),
3677 Ok(Err(e)) => Err(e),
3678 Err(Ok(e)) => Err(e),
3679 Err(Err(e)) => self.then_construct_error(
3680 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3681 handle.node_id(),
3682 NodeKind::NonTerminal(handle.kind()),
3683 e,
3684 tree,
3685 ),
3686 };
3687 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3688 result
3689 }
3690 fn visit_array_elements_opt_handle(
3691 &mut self,
3692 handle: ArrayElementsOptHandle,
3693 tree: &F,
3694 ) -> Result<(), V::Error> {
3695 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3696 Ok(nt_data) => nt_data,
3697 Err(error) => {
3698 return self.then_construct_error(
3699 None,
3700 handle.node_id(),
3701 NodeKind::NonTerminal(handle.kind()),
3702 error,
3703 tree,
3704 );
3705 }
3706 };
3707 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3708 let result = match handle
3709 .get_view_with_visit(
3710 tree,
3711 |view, visit: &mut Self| {
3712 (
3713 if let Some(view) = view {
3714 visit.visit_array_elements_opt(handle, view, tree)
3715 } else {
3716 Ok(())
3717 },
3718 visit,
3719 )
3720 },
3721 self,
3722 )
3723 .map_err(|e| e.extract_error())
3724 {
3725 Ok(Ok(())) => Ok(()),
3726 Ok(Err(e)) => Err(e),
3727 Err(Ok(e)) => Err(e),
3728 Err(Err(e)) => self.then_construct_error(
3729 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3730 handle.node_id(),
3731 NodeKind::NonTerminal(handle.kind()),
3732 e,
3733 tree,
3734 ),
3735 };
3736 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3737 result
3738 }
3739 fn visit_array_elements_tail_handle(
3740 &mut self,
3741 handle: ArrayElementsTailHandle,
3742 tree: &F,
3743 ) -> Result<(), V::Error> {
3744 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3745 Ok(nt_data) => nt_data,
3746 Err(error) => {
3747 return self.then_construct_error(
3748 None,
3749 handle.node_id(),
3750 NodeKind::NonTerminal(handle.kind()),
3751 error,
3752 tree,
3753 );
3754 }
3755 };
3756 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3757 let result = match handle
3758 .get_view_with_visit(
3759 tree,
3760 |view, visit: &mut Self| {
3761 (visit.visit_array_elements_tail(handle, view, tree), visit)
3762 },
3763 self,
3764 )
3765 .map_err(|e| e.extract_error())
3766 {
3767 Ok(Ok(())) => Ok(()),
3768 Ok(Err(e)) => Err(e),
3769 Err(Ok(e)) => Err(e),
3770 Err(Err(e)) => self.then_construct_error(
3771 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3772 handle.node_id(),
3773 NodeKind::NonTerminal(handle.kind()),
3774 e,
3775 tree,
3776 ),
3777 };
3778 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3779 result
3780 }
3781 fn visit_array_elements_tail_opt_handle(
3782 &mut self,
3783 handle: ArrayElementsTailOptHandle,
3784 tree: &F,
3785 ) -> Result<(), V::Error> {
3786 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3787 Ok(nt_data) => nt_data,
3788 Err(error) => {
3789 return self.then_construct_error(
3790 None,
3791 handle.node_id(),
3792 NodeKind::NonTerminal(handle.kind()),
3793 error,
3794 tree,
3795 );
3796 }
3797 };
3798 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3799 let result = match handle
3800 .get_view_with_visit(
3801 tree,
3802 |view, visit: &mut Self| {
3803 (
3804 if let Some(view) = view {
3805 visit.visit_array_elements_tail_opt(handle, view, tree)
3806 } else {
3807 Ok(())
3808 },
3809 visit,
3810 )
3811 },
3812 self,
3813 )
3814 .map_err(|e| e.extract_error())
3815 {
3816 Ok(Ok(())) => Ok(()),
3817 Ok(Err(e)) => Err(e),
3818 Err(Ok(e)) => Err(e),
3819 Err(Err(e)) => self.then_construct_error(
3820 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3821 handle.node_id(),
3822 NodeKind::NonTerminal(handle.kind()),
3823 e,
3824 tree,
3825 ),
3826 };
3827 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3828 result
3829 }
3830 fn visit_array_end_handle(&mut self, handle: ArrayEndHandle, tree: &F) -> Result<(), V::Error> {
3831 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3832 Ok(nt_data) => nt_data,
3833 Err(error) => {
3834 return self.then_construct_error(
3835 None,
3836 handle.node_id(),
3837 NodeKind::NonTerminal(handle.kind()),
3838 error,
3839 tree,
3840 );
3841 }
3842 };
3843 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3844 let result = match handle
3845 .get_view_with_visit(
3846 tree,
3847 |view, visit: &mut Self| (visit.visit_array_end(handle, view, tree), visit),
3848 self,
3849 )
3850 .map_err(|e| e.extract_error())
3851 {
3852 Ok(Ok(())) => Ok(()),
3853 Ok(Err(e)) => Err(e),
3854 Err(Ok(e)) => Err(e),
3855 Err(Err(e)) => self.then_construct_error(
3856 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3857 handle.node_id(),
3858 NodeKind::NonTerminal(handle.kind()),
3859 e,
3860 tree,
3861 ),
3862 };
3863 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3864 result
3865 }
3866 fn visit_array_marker_handle(
3867 &mut self,
3868 handle: ArrayMarkerHandle,
3869 tree: &F,
3870 ) -> Result<(), V::Error> {
3871 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3872 Ok(nt_data) => nt_data,
3873 Err(error) => {
3874 return self.then_construct_error(
3875 None,
3876 handle.node_id(),
3877 NodeKind::NonTerminal(handle.kind()),
3878 error,
3879 tree,
3880 );
3881 }
3882 };
3883 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3884 let result = match handle
3885 .get_view_with_visit(
3886 tree,
3887 |view, visit: &mut Self| (visit.visit_array_marker(handle, view, tree), visit),
3888 self,
3889 )
3890 .map_err(|e| e.extract_error())
3891 {
3892 Ok(Ok(())) => Ok(()),
3893 Ok(Err(e)) => Err(e),
3894 Err(Ok(e)) => Err(e),
3895 Err(Err(e)) => self.then_construct_error(
3896 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3897 handle.node_id(),
3898 NodeKind::NonTerminal(handle.kind()),
3899 e,
3900 tree,
3901 ),
3902 };
3903 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3904 result
3905 }
3906 fn visit_array_marker_opt_handle(
3907 &mut self,
3908 handle: ArrayMarkerOptHandle,
3909 tree: &F,
3910 ) -> Result<(), V::Error> {
3911 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3912 Ok(nt_data) => nt_data,
3913 Err(error) => {
3914 return self.then_construct_error(
3915 None,
3916 handle.node_id(),
3917 NodeKind::NonTerminal(handle.kind()),
3918 error,
3919 tree,
3920 );
3921 }
3922 };
3923 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3924 let result = match handle
3925 .get_view_with_visit(
3926 tree,
3927 |view, visit: &mut Self| {
3928 (
3929 if let Some(view) = view {
3930 visit.visit_array_marker_opt(handle, view, tree)
3931 } else {
3932 Ok(())
3933 },
3934 visit,
3935 )
3936 },
3937 self,
3938 )
3939 .map_err(|e| e.extract_error())
3940 {
3941 Ok(Ok(())) => Ok(()),
3942 Ok(Err(e)) => Err(e),
3943 Err(Ok(e)) => Err(e),
3944 Err(Err(e)) => self.then_construct_error(
3945 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3946 handle.node_id(),
3947 NodeKind::NonTerminal(handle.kind()),
3948 e,
3949 tree,
3950 ),
3951 };
3952 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3953 result
3954 }
3955 fn visit_array_opt_handle(&mut self, handle: ArrayOptHandle, tree: &F) -> Result<(), V::Error> {
3956 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
3957 Ok(nt_data) => nt_data,
3958 Err(error) => {
3959 return self.then_construct_error(
3960 None,
3961 handle.node_id(),
3962 NodeKind::NonTerminal(handle.kind()),
3963 error,
3964 tree,
3965 );
3966 }
3967 };
3968 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
3969 let result = match handle
3970 .get_view_with_visit(
3971 tree,
3972 |view, visit: &mut Self| {
3973 (
3974 if let Some(view) = view {
3975 visit.visit_array_opt(handle, view, tree)
3976 } else {
3977 Ok(())
3978 },
3979 visit,
3980 )
3981 },
3982 self,
3983 )
3984 .map_err(|e| e.extract_error())
3985 {
3986 Ok(Ok(())) => Ok(()),
3987 Ok(Err(e)) => Err(e),
3988 Err(Ok(e)) => Err(e),
3989 Err(Err(e)) => self.then_construct_error(
3990 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
3991 handle.node_id(),
3992 NodeKind::NonTerminal(handle.kind()),
3993 e,
3994 tree,
3995 ),
3996 };
3997 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
3998 result
3999 }
4000 fn visit_at_handle(&mut self, handle: AtHandle, tree: &F) -> Result<(), V::Error> {
4001 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4002 Ok(nt_data) => nt_data,
4003 Err(error) => {
4004 return self.then_construct_error(
4005 None,
4006 handle.node_id(),
4007 NodeKind::NonTerminal(handle.kind()),
4008 error,
4009 tree,
4010 );
4011 }
4012 };
4013 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4014 let result = match handle
4015 .get_view_with_visit(
4016 tree,
4017 |view, visit: &mut Self| (visit.visit_at(handle, view, tree), visit),
4018 self,
4019 )
4020 .map_err(|e| e.extract_error())
4021 {
4022 Ok(Ok(())) => Ok(()),
4023 Ok(Err(e)) => Err(e),
4024 Err(Ok(e)) => Err(e),
4025 Err(Err(e)) => self.then_construct_error(
4026 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4027 handle.node_id(),
4028 NodeKind::NonTerminal(handle.kind()),
4029 e,
4030 tree,
4031 ),
4032 };
4033 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4034 result
4035 }
4036 fn visit_backtick_2_handle(
4037 &mut self,
4038 handle: Backtick2Handle,
4039 tree: &F,
4040 ) -> Result<(), V::Error> {
4041 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4042 Ok(nt_data) => nt_data,
4043 Err(error) => {
4044 return self.then_construct_error(
4045 None,
4046 handle.node_id(),
4047 NodeKind::NonTerminal(handle.kind()),
4048 error,
4049 tree,
4050 );
4051 }
4052 };
4053 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4054 let result = match handle
4055 .get_view_with_visit(
4056 tree,
4057 |view, visit: &mut Self| (visit.visit_backtick_2(handle, view, tree), visit),
4058 self,
4059 )
4060 .map_err(|e| e.extract_error())
4061 {
4062 Ok(Ok(())) => Ok(()),
4063 Ok(Err(e)) => Err(e),
4064 Err(Ok(e)) => Err(e),
4065 Err(Err(e)) => self.then_construct_error(
4066 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4067 handle.node_id(),
4068 NodeKind::NonTerminal(handle.kind()),
4069 e,
4070 tree,
4071 ),
4072 };
4073 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4074 result
4075 }
4076 fn visit_backtick_3_handle(
4077 &mut self,
4078 handle: Backtick3Handle,
4079 tree: &F,
4080 ) -> Result<(), V::Error> {
4081 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4082 Ok(nt_data) => nt_data,
4083 Err(error) => {
4084 return self.then_construct_error(
4085 None,
4086 handle.node_id(),
4087 NodeKind::NonTerminal(handle.kind()),
4088 error,
4089 tree,
4090 );
4091 }
4092 };
4093 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4094 let result = match handle
4095 .get_view_with_visit(
4096 tree,
4097 |view, visit: &mut Self| (visit.visit_backtick_3(handle, view, tree), visit),
4098 self,
4099 )
4100 .map_err(|e| e.extract_error())
4101 {
4102 Ok(Ok(())) => Ok(()),
4103 Ok(Err(e)) => Err(e),
4104 Err(Ok(e)) => Err(e),
4105 Err(Err(e)) => self.then_construct_error(
4106 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4107 handle.node_id(),
4108 NodeKind::NonTerminal(handle.kind()),
4109 e,
4110 tree,
4111 ),
4112 };
4113 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4114 result
4115 }
4116 fn visit_backtick_4_handle(
4117 &mut self,
4118 handle: Backtick4Handle,
4119 tree: &F,
4120 ) -> Result<(), V::Error> {
4121 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4122 Ok(nt_data) => nt_data,
4123 Err(error) => {
4124 return self.then_construct_error(
4125 None,
4126 handle.node_id(),
4127 NodeKind::NonTerminal(handle.kind()),
4128 error,
4129 tree,
4130 );
4131 }
4132 };
4133 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4134 let result = match handle
4135 .get_view_with_visit(
4136 tree,
4137 |view, visit: &mut Self| (visit.visit_backtick_4(handle, view, tree), visit),
4138 self,
4139 )
4140 .map_err(|e| e.extract_error())
4141 {
4142 Ok(Ok(())) => Ok(()),
4143 Ok(Err(e)) => Err(e),
4144 Err(Ok(e)) => Err(e),
4145 Err(Err(e)) => self.then_construct_error(
4146 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4147 handle.node_id(),
4148 NodeKind::NonTerminal(handle.kind()),
4149 e,
4150 tree,
4151 ),
4152 };
4153 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4154 result
4155 }
4156 fn visit_backtick_5_handle(
4157 &mut self,
4158 handle: Backtick5Handle,
4159 tree: &F,
4160 ) -> Result<(), V::Error> {
4161 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4162 Ok(nt_data) => nt_data,
4163 Err(error) => {
4164 return self.then_construct_error(
4165 None,
4166 handle.node_id(),
4167 NodeKind::NonTerminal(handle.kind()),
4168 error,
4169 tree,
4170 );
4171 }
4172 };
4173 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4174 let result = match handle
4175 .get_view_with_visit(
4176 tree,
4177 |view, visit: &mut Self| (visit.visit_backtick_5(handle, view, tree), visit),
4178 self,
4179 )
4180 .map_err(|e| e.extract_error())
4181 {
4182 Ok(Ok(())) => Ok(()),
4183 Ok(Err(e)) => Err(e),
4184 Err(Ok(e)) => Err(e),
4185 Err(Err(e)) => self.then_construct_error(
4186 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4187 handle.node_id(),
4188 NodeKind::NonTerminal(handle.kind()),
4189 e,
4190 tree,
4191 ),
4192 };
4193 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4194 result
4195 }
4196 fn visit_backtick_delim_handle(
4197 &mut self,
4198 handle: BacktickDelimHandle,
4199 tree: &F,
4200 ) -> Result<(), V::Error> {
4201 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4202 Ok(nt_data) => nt_data,
4203 Err(error) => {
4204 return self.then_construct_error(
4205 None,
4206 handle.node_id(),
4207 NodeKind::NonTerminal(handle.kind()),
4208 error,
4209 tree,
4210 );
4211 }
4212 };
4213 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4214 let result = match handle
4215 .get_view_with_visit(
4216 tree,
4217 |view, visit: &mut Self| (visit.visit_backtick_delim(handle, view, tree), visit),
4218 self,
4219 )
4220 .map_err(|e| e.extract_error())
4221 {
4222 Ok(Ok(())) => Ok(()),
4223 Ok(Err(e)) => Err(e),
4224 Err(Ok(e)) => Err(e),
4225 Err(Err(e)) => self.then_construct_error(
4226 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4227 handle.node_id(),
4228 NodeKind::NonTerminal(handle.kind()),
4229 e,
4230 tree,
4231 ),
4232 };
4233 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4234 result
4235 }
4236 fn visit_begin_handle(&mut self, handle: BeginHandle, tree: &F) -> Result<(), V::Error> {
4237 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4238 Ok(nt_data) => nt_data,
4239 Err(error) => {
4240 return self.then_construct_error(
4241 None,
4242 handle.node_id(),
4243 NodeKind::NonTerminal(handle.kind()),
4244 error,
4245 tree,
4246 );
4247 }
4248 };
4249 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4250 let result = match handle
4251 .get_view_with_visit(
4252 tree,
4253 |view, visit: &mut Self| (visit.visit_begin(handle, view, tree), visit),
4254 self,
4255 )
4256 .map_err(|e| e.extract_error())
4257 {
4258 Ok(Ok(())) => Ok(()),
4259 Ok(Err(e)) => Err(e),
4260 Err(Ok(e)) => Err(e),
4261 Err(Err(e)) => self.then_construct_error(
4262 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4263 handle.node_id(),
4264 NodeKind::NonTerminal(handle.kind()),
4265 e,
4266 tree,
4267 ),
4268 };
4269 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4270 result
4271 }
4272 fn visit_bind_handle(&mut self, handle: BindHandle, tree: &F) -> Result<(), V::Error> {
4273 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4274 Ok(nt_data) => nt_data,
4275 Err(error) => {
4276 return self.then_construct_error(
4277 None,
4278 handle.node_id(),
4279 NodeKind::NonTerminal(handle.kind()),
4280 error,
4281 tree,
4282 );
4283 }
4284 };
4285 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4286 let result = match handle
4287 .get_view_with_visit(
4288 tree,
4289 |view, visit: &mut Self| (visit.visit_bind(handle, view, tree), visit),
4290 self,
4291 )
4292 .map_err(|e| e.extract_error())
4293 {
4294 Ok(Ok(())) => Ok(()),
4295 Ok(Err(e)) => Err(e),
4296 Err(Ok(e)) => Err(e),
4297 Err(Err(e)) => self.then_construct_error(
4298 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4299 handle.node_id(),
4300 NodeKind::NonTerminal(handle.kind()),
4301 e,
4302 tree,
4303 ),
4304 };
4305 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4306 result
4307 }
4308 fn visit_binding_handle(&mut self, handle: BindingHandle, tree: &F) -> Result<(), V::Error> {
4309 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4310 Ok(nt_data) => nt_data,
4311 Err(error) => {
4312 return self.then_construct_error(
4313 None,
4314 handle.node_id(),
4315 NodeKind::NonTerminal(handle.kind()),
4316 error,
4317 tree,
4318 );
4319 }
4320 };
4321 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4322 let result = match handle
4323 .get_view_with_visit(
4324 tree,
4325 |view, visit: &mut Self| (visit.visit_binding(handle, view, tree), visit),
4326 self,
4327 )
4328 .map_err(|e| e.extract_error())
4329 {
4330 Ok(Ok(())) => Ok(()),
4331 Ok(Err(e)) => Err(e),
4332 Err(Ok(e)) => Err(e),
4333 Err(Err(e)) => self.then_construct_error(
4334 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4335 handle.node_id(),
4336 NodeKind::NonTerminal(handle.kind()),
4337 e,
4338 tree,
4339 ),
4340 };
4341 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4342 result
4343 }
4344 fn visit_binding_rhs_handle(
4345 &mut self,
4346 handle: BindingRhsHandle,
4347 tree: &F,
4348 ) -> Result<(), V::Error> {
4349 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4350 Ok(nt_data) => nt_data,
4351 Err(error) => {
4352 return self.then_construct_error(
4353 None,
4354 handle.node_id(),
4355 NodeKind::NonTerminal(handle.kind()),
4356 error,
4357 tree,
4358 );
4359 }
4360 };
4361 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4362 let result = match handle
4363 .get_view_with_visit(
4364 tree,
4365 |view, visit: &mut Self| (visit.visit_binding_rhs(handle, view, tree), visit),
4366 self,
4367 )
4368 .map_err(|e| e.extract_error())
4369 {
4370 Ok(Ok(())) => Ok(()),
4371 Ok(Err(e)) => Err(e),
4372 Err(Ok(e)) => Err(e),
4373 Err(Err(e)) => self.then_construct_error(
4374 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4375 handle.node_id(),
4376 NodeKind::NonTerminal(handle.kind()),
4377 e,
4378 tree,
4379 ),
4380 };
4381 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4382 result
4383 }
4384 fn visit_block_body_handle(
4385 &mut self,
4386 handle: BlockBodyHandle,
4387 tree: &F,
4388 ) -> Result<(), V::Error> {
4389 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4390 Ok(nt_data) => nt_data,
4391 Err(error) => {
4392 return self.then_construct_error(
4393 None,
4394 handle.node_id(),
4395 NodeKind::NonTerminal(handle.kind()),
4396 error,
4397 tree,
4398 );
4399 }
4400 };
4401 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4402 let result = match handle
4403 .get_view_with_visit(
4404 tree,
4405 |view, visit: &mut Self| (visit.visit_block_body(handle, view, tree), visit),
4406 self,
4407 )
4408 .map_err(|e| e.extract_error())
4409 {
4410 Ok(Ok(())) => Ok(()),
4411 Ok(Err(e)) => Err(e),
4412 Err(Ok(e)) => Err(e),
4413 Err(Err(e)) => self.then_construct_error(
4414 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4415 handle.node_id(),
4416 NodeKind::NonTerminal(handle.kind()),
4417 e,
4418 tree,
4419 ),
4420 };
4421 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4422 result
4423 }
4424 fn visit_boolean_handle(&mut self, handle: BooleanHandle, tree: &F) -> Result<(), V::Error> {
4425 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4426 Ok(nt_data) => nt_data,
4427 Err(error) => {
4428 return self.then_construct_error(
4429 None,
4430 handle.node_id(),
4431 NodeKind::NonTerminal(handle.kind()),
4432 error,
4433 tree,
4434 );
4435 }
4436 };
4437 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4438 let result = match handle
4439 .get_view_with_visit(
4440 tree,
4441 |view, visit: &mut Self| (visit.visit_boolean(handle, view, tree), visit),
4442 self,
4443 )
4444 .map_err(|e| e.extract_error())
4445 {
4446 Ok(Ok(())) => Ok(()),
4447 Ok(Err(e)) => Err(e),
4448 Err(Ok(e)) => Err(e),
4449 Err(Err(e)) => self.then_construct_error(
4450 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4451 handle.node_id(),
4452 NodeKind::NonTerminal(handle.kind()),
4453 e,
4454 tree,
4455 ),
4456 };
4457 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4458 result
4459 }
4460 fn visit_code_block_handle(
4461 &mut self,
4462 handle: CodeBlockHandle,
4463 tree: &F,
4464 ) -> Result<(), V::Error> {
4465 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4466 Ok(nt_data) => nt_data,
4467 Err(error) => {
4468 return self.then_construct_error(
4469 None,
4470 handle.node_id(),
4471 NodeKind::NonTerminal(handle.kind()),
4472 error,
4473 tree,
4474 );
4475 }
4476 };
4477 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4478 let result = match handle
4479 .get_view_with_visit(
4480 tree,
4481 |view, visit: &mut Self| (visit.visit_code_block(handle, view, tree), visit),
4482 self,
4483 )
4484 .map_err(|e| e.extract_error())
4485 {
4486 Ok(Ok(())) => Ok(()),
4487 Ok(Err(e)) => Err(e),
4488 Err(Ok(e)) => Err(e),
4489 Err(Err(e)) => self.then_construct_error(
4490 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4491 handle.node_id(),
4492 NodeKind::NonTerminal(handle.kind()),
4493 e,
4494 tree,
4495 ),
4496 };
4497 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4498 result
4499 }
4500 fn visit_code_block_3_handle(
4501 &mut self,
4502 handle: CodeBlock3Handle,
4503 tree: &F,
4504 ) -> Result<(), V::Error> {
4505 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4506 Ok(nt_data) => nt_data,
4507 Err(error) => {
4508 return self.then_construct_error(
4509 None,
4510 handle.node_id(),
4511 NodeKind::NonTerminal(handle.kind()),
4512 error,
4513 tree,
4514 );
4515 }
4516 };
4517 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4518 let result = match handle
4519 .get_view_with_visit(
4520 tree,
4521 |view, visit: &mut Self| (visit.visit_code_block_3(handle, view, tree), visit),
4522 self,
4523 )
4524 .map_err(|e| e.extract_error())
4525 {
4526 Ok(Ok(())) => Ok(()),
4527 Ok(Err(e)) => Err(e),
4528 Err(Ok(e)) => Err(e),
4529 Err(Err(e)) => self.then_construct_error(
4530 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4531 handle.node_id(),
4532 NodeKind::NonTerminal(handle.kind()),
4533 e,
4534 tree,
4535 ),
4536 };
4537 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4538 result
4539 }
4540 fn visit_code_block_3_list_handle(
4541 &mut self,
4542 handle: CodeBlock3ListHandle,
4543 tree: &F,
4544 ) -> Result<(), V::Error> {
4545 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4546 Ok(nt_data) => nt_data,
4547 Err(error) => {
4548 return self.then_construct_error(
4549 None,
4550 handle.node_id(),
4551 NodeKind::NonTerminal(handle.kind()),
4552 error,
4553 tree,
4554 );
4555 }
4556 };
4557 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4558 let result = match handle
4559 .get_view_with_visit(
4560 tree,
4561 |view, visit: &mut Self| {
4562 (
4563 if let Some(view) = view {
4564 visit.visit_code_block_3_list(handle, view, tree)
4565 } else {
4566 Ok(())
4567 },
4568 visit,
4569 )
4570 },
4571 self,
4572 )
4573 .map_err(|e| e.extract_error())
4574 {
4575 Ok(Ok(())) => Ok(()),
4576 Ok(Err(e)) => Err(e),
4577 Err(Ok(e)) => Err(e),
4578 Err(Err(e)) => self.then_construct_error(
4579 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4580 handle.node_id(),
4581 NodeKind::NonTerminal(handle.kind()),
4582 e,
4583 tree,
4584 ),
4585 };
4586 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4587 result
4588 }
4589 fn visit_code_block_3_list_group_handle(
4590 &mut self,
4591 handle: CodeBlock3ListGroupHandle,
4592 tree: &F,
4593 ) -> Result<(), V::Error> {
4594 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4595 Ok(nt_data) => nt_data,
4596 Err(error) => {
4597 return self.then_construct_error(
4598 None,
4599 handle.node_id(),
4600 NodeKind::NonTerminal(handle.kind()),
4601 error,
4602 tree,
4603 );
4604 }
4605 };
4606 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4607 let result = match handle
4608 .get_view_with_visit(
4609 tree,
4610 |view, visit: &mut Self| {
4611 (
4612 visit.visit_code_block_3_list_group(handle, view, tree),
4613 visit,
4614 )
4615 },
4616 self,
4617 )
4618 .map_err(|e| e.extract_error())
4619 {
4620 Ok(Ok(())) => Ok(()),
4621 Ok(Err(e)) => Err(e),
4622 Err(Ok(e)) => Err(e),
4623 Err(Err(e)) => self.then_construct_error(
4624 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4625 handle.node_id(),
4626 NodeKind::NonTerminal(handle.kind()),
4627 e,
4628 tree,
4629 ),
4630 };
4631 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4632 result
4633 }
4634 fn visit_code_block_4_handle(
4635 &mut self,
4636 handle: CodeBlock4Handle,
4637 tree: &F,
4638 ) -> Result<(), V::Error> {
4639 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4640 Ok(nt_data) => nt_data,
4641 Err(error) => {
4642 return self.then_construct_error(
4643 None,
4644 handle.node_id(),
4645 NodeKind::NonTerminal(handle.kind()),
4646 error,
4647 tree,
4648 );
4649 }
4650 };
4651 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4652 let result = match handle
4653 .get_view_with_visit(
4654 tree,
4655 |view, visit: &mut Self| (visit.visit_code_block_4(handle, view, tree), visit),
4656 self,
4657 )
4658 .map_err(|e| e.extract_error())
4659 {
4660 Ok(Ok(())) => Ok(()),
4661 Ok(Err(e)) => Err(e),
4662 Err(Ok(e)) => Err(e),
4663 Err(Err(e)) => self.then_construct_error(
4664 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4665 handle.node_id(),
4666 NodeKind::NonTerminal(handle.kind()),
4667 e,
4668 tree,
4669 ),
4670 };
4671 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4672 result
4673 }
4674 fn visit_code_block_4_list_handle(
4675 &mut self,
4676 handle: CodeBlock4ListHandle,
4677 tree: &F,
4678 ) -> Result<(), V::Error> {
4679 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4680 Ok(nt_data) => nt_data,
4681 Err(error) => {
4682 return self.then_construct_error(
4683 None,
4684 handle.node_id(),
4685 NodeKind::NonTerminal(handle.kind()),
4686 error,
4687 tree,
4688 );
4689 }
4690 };
4691 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4692 let result = match handle
4693 .get_view_with_visit(
4694 tree,
4695 |view, visit: &mut Self| {
4696 (
4697 if let Some(view) = view {
4698 visit.visit_code_block_4_list(handle, view, tree)
4699 } else {
4700 Ok(())
4701 },
4702 visit,
4703 )
4704 },
4705 self,
4706 )
4707 .map_err(|e| e.extract_error())
4708 {
4709 Ok(Ok(())) => Ok(()),
4710 Ok(Err(e)) => Err(e),
4711 Err(Ok(e)) => Err(e),
4712 Err(Err(e)) => self.then_construct_error(
4713 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4714 handle.node_id(),
4715 NodeKind::NonTerminal(handle.kind()),
4716 e,
4717 tree,
4718 ),
4719 };
4720 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4721 result
4722 }
4723 fn visit_code_block_4_list_group_handle(
4724 &mut self,
4725 handle: CodeBlock4ListGroupHandle,
4726 tree: &F,
4727 ) -> Result<(), V::Error> {
4728 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4729 Ok(nt_data) => nt_data,
4730 Err(error) => {
4731 return self.then_construct_error(
4732 None,
4733 handle.node_id(),
4734 NodeKind::NonTerminal(handle.kind()),
4735 error,
4736 tree,
4737 );
4738 }
4739 };
4740 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4741 let result = match handle
4742 .get_view_with_visit(
4743 tree,
4744 |view, visit: &mut Self| {
4745 (
4746 visit.visit_code_block_4_list_group(handle, view, tree),
4747 visit,
4748 )
4749 },
4750 self,
4751 )
4752 .map_err(|e| e.extract_error())
4753 {
4754 Ok(Ok(())) => Ok(()),
4755 Ok(Err(e)) => Err(e),
4756 Err(Ok(e)) => Err(e),
4757 Err(Err(e)) => self.then_construct_error(
4758 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4759 handle.node_id(),
4760 NodeKind::NonTerminal(handle.kind()),
4761 e,
4762 tree,
4763 ),
4764 };
4765 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4766 result
4767 }
4768 fn visit_code_block_5_handle(
4769 &mut self,
4770 handle: CodeBlock5Handle,
4771 tree: &F,
4772 ) -> Result<(), V::Error> {
4773 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4774 Ok(nt_data) => nt_data,
4775 Err(error) => {
4776 return self.then_construct_error(
4777 None,
4778 handle.node_id(),
4779 NodeKind::NonTerminal(handle.kind()),
4780 error,
4781 tree,
4782 );
4783 }
4784 };
4785 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4786 let result = match handle
4787 .get_view_with_visit(
4788 tree,
4789 |view, visit: &mut Self| (visit.visit_code_block_5(handle, view, tree), visit),
4790 self,
4791 )
4792 .map_err(|e| e.extract_error())
4793 {
4794 Ok(Ok(())) => Ok(()),
4795 Ok(Err(e)) => Err(e),
4796 Err(Ok(e)) => Err(e),
4797 Err(Err(e)) => self.then_construct_error(
4798 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4799 handle.node_id(),
4800 NodeKind::NonTerminal(handle.kind()),
4801 e,
4802 tree,
4803 ),
4804 };
4805 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4806 result
4807 }
4808 fn visit_code_block_5_list_handle(
4809 &mut self,
4810 handle: CodeBlock5ListHandle,
4811 tree: &F,
4812 ) -> Result<(), V::Error> {
4813 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4814 Ok(nt_data) => nt_data,
4815 Err(error) => {
4816 return self.then_construct_error(
4817 None,
4818 handle.node_id(),
4819 NodeKind::NonTerminal(handle.kind()),
4820 error,
4821 tree,
4822 );
4823 }
4824 };
4825 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4826 let result = match handle
4827 .get_view_with_visit(
4828 tree,
4829 |view, visit: &mut Self| {
4830 (
4831 if let Some(view) = view {
4832 visit.visit_code_block_5_list(handle, view, tree)
4833 } else {
4834 Ok(())
4835 },
4836 visit,
4837 )
4838 },
4839 self,
4840 )
4841 .map_err(|e| e.extract_error())
4842 {
4843 Ok(Ok(())) => Ok(()),
4844 Ok(Err(e)) => Err(e),
4845 Err(Ok(e)) => Err(e),
4846 Err(Err(e)) => self.then_construct_error(
4847 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4848 handle.node_id(),
4849 NodeKind::NonTerminal(handle.kind()),
4850 e,
4851 tree,
4852 ),
4853 };
4854 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4855 result
4856 }
4857 fn visit_code_block_5_list_group_handle(
4858 &mut self,
4859 handle: CodeBlock5ListGroupHandle,
4860 tree: &F,
4861 ) -> Result<(), V::Error> {
4862 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4863 Ok(nt_data) => nt_data,
4864 Err(error) => {
4865 return self.then_construct_error(
4866 None,
4867 handle.node_id(),
4868 NodeKind::NonTerminal(handle.kind()),
4869 error,
4870 tree,
4871 );
4872 }
4873 };
4874 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4875 let result = match handle
4876 .get_view_with_visit(
4877 tree,
4878 |view, visit: &mut Self| {
4879 (
4880 visit.visit_code_block_5_list_group(handle, view, tree),
4881 visit,
4882 )
4883 },
4884 self,
4885 )
4886 .map_err(|e| e.extract_error())
4887 {
4888 Ok(Ok(())) => Ok(()),
4889 Ok(Err(e)) => Err(e),
4890 Err(Ok(e)) => Err(e),
4891 Err(Err(e)) => self.then_construct_error(
4892 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4893 handle.node_id(),
4894 NodeKind::NonTerminal(handle.kind()),
4895 e,
4896 tree,
4897 ),
4898 };
4899 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4900 result
4901 }
4902 fn visit_code_block_6_handle(
4903 &mut self,
4904 handle: CodeBlock6Handle,
4905 tree: &F,
4906 ) -> Result<(), V::Error> {
4907 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4908 Ok(nt_data) => nt_data,
4909 Err(error) => {
4910 return self.then_construct_error(
4911 None,
4912 handle.node_id(),
4913 NodeKind::NonTerminal(handle.kind()),
4914 error,
4915 tree,
4916 );
4917 }
4918 };
4919 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4920 let result = match handle
4921 .get_view_with_visit(
4922 tree,
4923 |view, visit: &mut Self| (visit.visit_code_block_6(handle, view, tree), visit),
4924 self,
4925 )
4926 .map_err(|e| e.extract_error())
4927 {
4928 Ok(Ok(())) => Ok(()),
4929 Ok(Err(e)) => Err(e),
4930 Err(Ok(e)) => Err(e),
4931 Err(Err(e)) => self.then_construct_error(
4932 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4933 handle.node_id(),
4934 NodeKind::NonTerminal(handle.kind()),
4935 e,
4936 tree,
4937 ),
4938 };
4939 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4940 result
4941 }
4942 fn visit_code_block_6_list_handle(
4943 &mut self,
4944 handle: CodeBlock6ListHandle,
4945 tree: &F,
4946 ) -> Result<(), V::Error> {
4947 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4948 Ok(nt_data) => nt_data,
4949 Err(error) => {
4950 return self.then_construct_error(
4951 None,
4952 handle.node_id(),
4953 NodeKind::NonTerminal(handle.kind()),
4954 error,
4955 tree,
4956 );
4957 }
4958 };
4959 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
4960 let result = match handle
4961 .get_view_with_visit(
4962 tree,
4963 |view, visit: &mut Self| {
4964 (
4965 if let Some(view) = view {
4966 visit.visit_code_block_6_list(handle, view, tree)
4967 } else {
4968 Ok(())
4969 },
4970 visit,
4971 )
4972 },
4973 self,
4974 )
4975 .map_err(|e| e.extract_error())
4976 {
4977 Ok(Ok(())) => Ok(()),
4978 Ok(Err(e)) => Err(e),
4979 Err(Ok(e)) => Err(e),
4980 Err(Err(e)) => self.then_construct_error(
4981 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
4982 handle.node_id(),
4983 NodeKind::NonTerminal(handle.kind()),
4984 e,
4985 tree,
4986 ),
4987 };
4988 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
4989 result
4990 }
4991 fn visit_code_block_6_list_group_handle(
4992 &mut self,
4993 handle: CodeBlock6ListGroupHandle,
4994 tree: &F,
4995 ) -> Result<(), V::Error> {
4996 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
4997 Ok(nt_data) => nt_data,
4998 Err(error) => {
4999 return self.then_construct_error(
5000 None,
5001 handle.node_id(),
5002 NodeKind::NonTerminal(handle.kind()),
5003 error,
5004 tree,
5005 );
5006 }
5007 };
5008 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5009 let result = match handle
5010 .get_view_with_visit(
5011 tree,
5012 |view, visit: &mut Self| {
5013 (
5014 visit.visit_code_block_6_list_group(handle, view, tree),
5015 visit,
5016 )
5017 },
5018 self,
5019 )
5020 .map_err(|e| e.extract_error())
5021 {
5022 Ok(Ok(())) => Ok(()),
5023 Ok(Err(e)) => Err(e),
5024 Err(Ok(e)) => Err(e),
5025 Err(Err(e)) => self.then_construct_error(
5026 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5027 handle.node_id(),
5028 NodeKind::NonTerminal(handle.kind()),
5029 e,
5030 tree,
5031 ),
5032 };
5033 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5034 result
5035 }
5036 fn visit_code_block_end_3_handle(
5037 &mut self,
5038 handle: CodeBlockEnd3Handle,
5039 tree: &F,
5040 ) -> Result<(), V::Error> {
5041 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5042 Ok(nt_data) => nt_data,
5043 Err(error) => {
5044 return self.then_construct_error(
5045 None,
5046 handle.node_id(),
5047 NodeKind::NonTerminal(handle.kind()),
5048 error,
5049 tree,
5050 );
5051 }
5052 };
5053 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5054 let result = match handle
5055 .get_view_with_visit(
5056 tree,
5057 |view, visit: &mut Self| (visit.visit_code_block_end_3(handle, view, tree), visit),
5058 self,
5059 )
5060 .map_err(|e| e.extract_error())
5061 {
5062 Ok(Ok(())) => Ok(()),
5063 Ok(Err(e)) => Err(e),
5064 Err(Ok(e)) => Err(e),
5065 Err(Err(e)) => self.then_construct_error(
5066 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5067 handle.node_id(),
5068 NodeKind::NonTerminal(handle.kind()),
5069 e,
5070 tree,
5071 ),
5072 };
5073 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5074 result
5075 }
5076 fn visit_code_block_end_4_handle(
5077 &mut self,
5078 handle: CodeBlockEnd4Handle,
5079 tree: &F,
5080 ) -> Result<(), V::Error> {
5081 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5082 Ok(nt_data) => nt_data,
5083 Err(error) => {
5084 return self.then_construct_error(
5085 None,
5086 handle.node_id(),
5087 NodeKind::NonTerminal(handle.kind()),
5088 error,
5089 tree,
5090 );
5091 }
5092 };
5093 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5094 let result = match handle
5095 .get_view_with_visit(
5096 tree,
5097 |view, visit: &mut Self| (visit.visit_code_block_end_4(handle, view, tree), visit),
5098 self,
5099 )
5100 .map_err(|e| e.extract_error())
5101 {
5102 Ok(Ok(())) => Ok(()),
5103 Ok(Err(e)) => Err(e),
5104 Err(Ok(e)) => Err(e),
5105 Err(Err(e)) => self.then_construct_error(
5106 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5107 handle.node_id(),
5108 NodeKind::NonTerminal(handle.kind()),
5109 e,
5110 tree,
5111 ),
5112 };
5113 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5114 result
5115 }
5116 fn visit_code_block_end_5_handle(
5117 &mut self,
5118 handle: CodeBlockEnd5Handle,
5119 tree: &F,
5120 ) -> Result<(), V::Error> {
5121 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5122 Ok(nt_data) => nt_data,
5123 Err(error) => {
5124 return self.then_construct_error(
5125 None,
5126 handle.node_id(),
5127 NodeKind::NonTerminal(handle.kind()),
5128 error,
5129 tree,
5130 );
5131 }
5132 };
5133 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5134 let result = match handle
5135 .get_view_with_visit(
5136 tree,
5137 |view, visit: &mut Self| (visit.visit_code_block_end_5(handle, view, tree), visit),
5138 self,
5139 )
5140 .map_err(|e| e.extract_error())
5141 {
5142 Ok(Ok(())) => Ok(()),
5143 Ok(Err(e)) => Err(e),
5144 Err(Ok(e)) => Err(e),
5145 Err(Err(e)) => self.then_construct_error(
5146 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5147 handle.node_id(),
5148 NodeKind::NonTerminal(handle.kind()),
5149 e,
5150 tree,
5151 ),
5152 };
5153 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5154 result
5155 }
5156 fn visit_code_block_end_6_handle(
5157 &mut self,
5158 handle: CodeBlockEnd6Handle,
5159 tree: &F,
5160 ) -> Result<(), V::Error> {
5161 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5162 Ok(nt_data) => nt_data,
5163 Err(error) => {
5164 return self.then_construct_error(
5165 None,
5166 handle.node_id(),
5167 NodeKind::NonTerminal(handle.kind()),
5168 error,
5169 tree,
5170 );
5171 }
5172 };
5173 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5174 let result = match handle
5175 .get_view_with_visit(
5176 tree,
5177 |view, visit: &mut Self| (visit.visit_code_block_end_6(handle, view, tree), visit),
5178 self,
5179 )
5180 .map_err(|e| e.extract_error())
5181 {
5182 Ok(Ok(())) => Ok(()),
5183 Ok(Err(e)) => Err(e),
5184 Err(Ok(e)) => Err(e),
5185 Err(Err(e)) => self.then_construct_error(
5186 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5187 handle.node_id(),
5188 NodeKind::NonTerminal(handle.kind()),
5189 e,
5190 tree,
5191 ),
5192 };
5193 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5194 result
5195 }
5196 fn visit_code_block_start_3_handle(
5197 &mut self,
5198 handle: CodeBlockStart3Handle,
5199 tree: &F,
5200 ) -> Result<(), V::Error> {
5201 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5202 Ok(nt_data) => nt_data,
5203 Err(error) => {
5204 return self.then_construct_error(
5205 None,
5206 handle.node_id(),
5207 NodeKind::NonTerminal(handle.kind()),
5208 error,
5209 tree,
5210 );
5211 }
5212 };
5213 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5214 let result = match handle
5215 .get_view_with_visit(
5216 tree,
5217 |view, visit: &mut Self| {
5218 (visit.visit_code_block_start_3(handle, view, tree), visit)
5219 },
5220 self,
5221 )
5222 .map_err(|e| e.extract_error())
5223 {
5224 Ok(Ok(())) => Ok(()),
5225 Ok(Err(e)) => Err(e),
5226 Err(Ok(e)) => Err(e),
5227 Err(Err(e)) => self.then_construct_error(
5228 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5229 handle.node_id(),
5230 NodeKind::NonTerminal(handle.kind()),
5231 e,
5232 tree,
5233 ),
5234 };
5235 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5236 result
5237 }
5238 fn visit_code_block_start_4_handle(
5239 &mut self,
5240 handle: CodeBlockStart4Handle,
5241 tree: &F,
5242 ) -> Result<(), V::Error> {
5243 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5244 Ok(nt_data) => nt_data,
5245 Err(error) => {
5246 return self.then_construct_error(
5247 None,
5248 handle.node_id(),
5249 NodeKind::NonTerminal(handle.kind()),
5250 error,
5251 tree,
5252 );
5253 }
5254 };
5255 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5256 let result = match handle
5257 .get_view_with_visit(
5258 tree,
5259 |view, visit: &mut Self| {
5260 (visit.visit_code_block_start_4(handle, view, tree), visit)
5261 },
5262 self,
5263 )
5264 .map_err(|e| e.extract_error())
5265 {
5266 Ok(Ok(())) => Ok(()),
5267 Ok(Err(e)) => Err(e),
5268 Err(Ok(e)) => Err(e),
5269 Err(Err(e)) => self.then_construct_error(
5270 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5271 handle.node_id(),
5272 NodeKind::NonTerminal(handle.kind()),
5273 e,
5274 tree,
5275 ),
5276 };
5277 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5278 result
5279 }
5280 fn visit_code_block_start_5_handle(
5281 &mut self,
5282 handle: CodeBlockStart5Handle,
5283 tree: &F,
5284 ) -> Result<(), V::Error> {
5285 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5286 Ok(nt_data) => nt_data,
5287 Err(error) => {
5288 return self.then_construct_error(
5289 None,
5290 handle.node_id(),
5291 NodeKind::NonTerminal(handle.kind()),
5292 error,
5293 tree,
5294 );
5295 }
5296 };
5297 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5298 let result = match handle
5299 .get_view_with_visit(
5300 tree,
5301 |view, visit: &mut Self| {
5302 (visit.visit_code_block_start_5(handle, view, tree), visit)
5303 },
5304 self,
5305 )
5306 .map_err(|e| e.extract_error())
5307 {
5308 Ok(Ok(())) => Ok(()),
5309 Ok(Err(e)) => Err(e),
5310 Err(Ok(e)) => Err(e),
5311 Err(Err(e)) => self.then_construct_error(
5312 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5313 handle.node_id(),
5314 NodeKind::NonTerminal(handle.kind()),
5315 e,
5316 tree,
5317 ),
5318 };
5319 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5320 result
5321 }
5322 fn visit_code_block_start_6_handle(
5323 &mut self,
5324 handle: CodeBlockStart6Handle,
5325 tree: &F,
5326 ) -> Result<(), V::Error> {
5327 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5328 Ok(nt_data) => nt_data,
5329 Err(error) => {
5330 return self.then_construct_error(
5331 None,
5332 handle.node_id(),
5333 NodeKind::NonTerminal(handle.kind()),
5334 error,
5335 tree,
5336 );
5337 }
5338 };
5339 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5340 let result = match handle
5341 .get_view_with_visit(
5342 tree,
5343 |view, visit: &mut Self| {
5344 (visit.visit_code_block_start_6(handle, view, tree), visit)
5345 },
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_comma_handle(&mut self, handle: CommaHandle, 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_comma(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_continue_handle(&mut self, handle: ContinueHandle, 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| (visit.visit_continue(handle, view, tree), visit),
5418 self,
5419 )
5420 .map_err(|e| e.extract_error())
5421 {
5422 Ok(Ok(())) => Ok(()),
5423 Ok(Err(e)) => Err(e),
5424 Err(Ok(e)) => Err(e),
5425 Err(Err(e)) => self.then_construct_error(
5426 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5427 handle.node_id(),
5428 NodeKind::NonTerminal(handle.kind()),
5429 e,
5430 tree,
5431 ),
5432 };
5433 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5434 result
5435 }
5436 fn visit_delim_code_handle(
5437 &mut self,
5438 handle: DelimCodeHandle,
5439 tree: &F,
5440 ) -> Result<(), V::Error> {
5441 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5442 Ok(nt_data) => nt_data,
5443 Err(error) => {
5444 return self.then_construct_error(
5445 None,
5446 handle.node_id(),
5447 NodeKind::NonTerminal(handle.kind()),
5448 error,
5449 tree,
5450 );
5451 }
5452 };
5453 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5454 let result = match handle
5455 .get_view_with_visit(
5456 tree,
5457 |view, visit: &mut Self| (visit.visit_delim_code(handle, view, tree), visit),
5458 self,
5459 )
5460 .map_err(|e| e.extract_error())
5461 {
5462 Ok(Ok(())) => Ok(()),
5463 Ok(Err(e)) => Err(e),
5464 Err(Ok(e)) => Err(e),
5465 Err(Err(e)) => self.then_construct_error(
5466 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5467 handle.node_id(),
5468 NodeKind::NonTerminal(handle.kind()),
5469 e,
5470 tree,
5471 ),
5472 };
5473 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5474 result
5475 }
5476 fn visit_delim_code_1_handle(
5477 &mut self,
5478 handle: DelimCode1Handle,
5479 tree: &F,
5480 ) -> Result<(), V::Error> {
5481 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5482 Ok(nt_data) => nt_data,
5483 Err(error) => {
5484 return self.then_construct_error(
5485 None,
5486 handle.node_id(),
5487 NodeKind::NonTerminal(handle.kind()),
5488 error,
5489 tree,
5490 );
5491 }
5492 };
5493 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5494 let result = match handle
5495 .get_view_with_visit(
5496 tree,
5497 |view, visit: &mut Self| (visit.visit_delim_code_1(handle, view, tree), visit),
5498 self,
5499 )
5500 .map_err(|e| e.extract_error())
5501 {
5502 Ok(Ok(())) => Ok(()),
5503 Ok(Err(e)) => Err(e),
5504 Err(Ok(e)) => Err(e),
5505 Err(Err(e)) => self.then_construct_error(
5506 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5507 handle.node_id(),
5508 NodeKind::NonTerminal(handle.kind()),
5509 e,
5510 tree,
5511 ),
5512 };
5513 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5514 result
5515 }
5516 fn visit_delim_code_1_list_handle(
5517 &mut self,
5518 handle: DelimCode1ListHandle,
5519 tree: &F,
5520 ) -> Result<(), V::Error> {
5521 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5522 Ok(nt_data) => nt_data,
5523 Err(error) => {
5524 return self.then_construct_error(
5525 None,
5526 handle.node_id(),
5527 NodeKind::NonTerminal(handle.kind()),
5528 error,
5529 tree,
5530 );
5531 }
5532 };
5533 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5534 let result = match handle
5535 .get_view_with_visit(
5536 tree,
5537 |view, visit: &mut Self| {
5538 (
5539 if let Some(view) = view {
5540 visit.visit_delim_code_1_list(handle, view, tree)
5541 } else {
5542 Ok(())
5543 },
5544 visit,
5545 )
5546 },
5547 self,
5548 )
5549 .map_err(|e| e.extract_error())
5550 {
5551 Ok(Ok(())) => Ok(()),
5552 Ok(Err(e)) => Err(e),
5553 Err(Ok(e)) => Err(e),
5554 Err(Err(e)) => self.then_construct_error(
5555 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5556 handle.node_id(),
5557 NodeKind::NonTerminal(handle.kind()),
5558 e,
5559 tree,
5560 ),
5561 };
5562 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5563 result
5564 }
5565 fn visit_delim_code_1_list_group_handle(
5566 &mut self,
5567 handle: DelimCode1ListGroupHandle,
5568 tree: &F,
5569 ) -> Result<(), V::Error> {
5570 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5571 Ok(nt_data) => nt_data,
5572 Err(error) => {
5573 return self.then_construct_error(
5574 None,
5575 handle.node_id(),
5576 NodeKind::NonTerminal(handle.kind()),
5577 error,
5578 tree,
5579 );
5580 }
5581 };
5582 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5583 let result = match handle
5584 .get_view_with_visit(
5585 tree,
5586 |view, visit: &mut Self| {
5587 (
5588 visit.visit_delim_code_1_list_group(handle, view, tree),
5589 visit,
5590 )
5591 },
5592 self,
5593 )
5594 .map_err(|e| e.extract_error())
5595 {
5596 Ok(Ok(())) => Ok(()),
5597 Ok(Err(e)) => Err(e),
5598 Err(Ok(e)) => Err(e),
5599 Err(Err(e)) => self.then_construct_error(
5600 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5601 handle.node_id(),
5602 NodeKind::NonTerminal(handle.kind()),
5603 e,
5604 tree,
5605 ),
5606 };
5607 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5608 result
5609 }
5610 fn visit_delim_code_2_handle(
5611 &mut self,
5612 handle: DelimCode2Handle,
5613 tree: &F,
5614 ) -> Result<(), V::Error> {
5615 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5616 Ok(nt_data) => nt_data,
5617 Err(error) => {
5618 return self.then_construct_error(
5619 None,
5620 handle.node_id(),
5621 NodeKind::NonTerminal(handle.kind()),
5622 error,
5623 tree,
5624 );
5625 }
5626 };
5627 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5628 let result = match handle
5629 .get_view_with_visit(
5630 tree,
5631 |view, visit: &mut Self| (visit.visit_delim_code_2(handle, view, tree), visit),
5632 self,
5633 )
5634 .map_err(|e| e.extract_error())
5635 {
5636 Ok(Ok(())) => Ok(()),
5637 Ok(Err(e)) => Err(e),
5638 Err(Ok(e)) => Err(e),
5639 Err(Err(e)) => self.then_construct_error(
5640 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5641 handle.node_id(),
5642 NodeKind::NonTerminal(handle.kind()),
5643 e,
5644 tree,
5645 ),
5646 };
5647 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5648 result
5649 }
5650 fn visit_delim_code_2_list_handle(
5651 &mut self,
5652 handle: DelimCode2ListHandle,
5653 tree: &F,
5654 ) -> Result<(), V::Error> {
5655 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5656 Ok(nt_data) => nt_data,
5657 Err(error) => {
5658 return self.then_construct_error(
5659 None,
5660 handle.node_id(),
5661 NodeKind::NonTerminal(handle.kind()),
5662 error,
5663 tree,
5664 );
5665 }
5666 };
5667 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5668 let result = match handle
5669 .get_view_with_visit(
5670 tree,
5671 |view, visit: &mut Self| {
5672 (
5673 if let Some(view) = view {
5674 visit.visit_delim_code_2_list(handle, view, tree)
5675 } else {
5676 Ok(())
5677 },
5678 visit,
5679 )
5680 },
5681 self,
5682 )
5683 .map_err(|e| e.extract_error())
5684 {
5685 Ok(Ok(())) => Ok(()),
5686 Ok(Err(e)) => Err(e),
5687 Err(Ok(e)) => Err(e),
5688 Err(Err(e)) => self.then_construct_error(
5689 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5690 handle.node_id(),
5691 NodeKind::NonTerminal(handle.kind()),
5692 e,
5693 tree,
5694 ),
5695 };
5696 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5697 result
5698 }
5699 fn visit_delim_code_2_list_group_handle(
5700 &mut self,
5701 handle: DelimCode2ListGroupHandle,
5702 tree: &F,
5703 ) -> Result<(), V::Error> {
5704 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5705 Ok(nt_data) => nt_data,
5706 Err(error) => {
5707 return self.then_construct_error(
5708 None,
5709 handle.node_id(),
5710 NodeKind::NonTerminal(handle.kind()),
5711 error,
5712 tree,
5713 );
5714 }
5715 };
5716 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5717 let result = match handle
5718 .get_view_with_visit(
5719 tree,
5720 |view, visit: &mut Self| {
5721 (
5722 visit.visit_delim_code_2_list_group(handle, view, tree),
5723 visit,
5724 )
5725 },
5726 self,
5727 )
5728 .map_err(|e| e.extract_error())
5729 {
5730 Ok(Ok(())) => Ok(()),
5731 Ok(Err(e)) => Err(e),
5732 Err(Ok(e)) => Err(e),
5733 Err(Err(e)) => self.then_construct_error(
5734 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5735 handle.node_id(),
5736 NodeKind::NonTerminal(handle.kind()),
5737 e,
5738 tree,
5739 ),
5740 };
5741 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5742 result
5743 }
5744 fn visit_delim_code_3_handle(
5745 &mut self,
5746 handle: DelimCode3Handle,
5747 tree: &F,
5748 ) -> Result<(), V::Error> {
5749 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5750 Ok(nt_data) => nt_data,
5751 Err(error) => {
5752 return self.then_construct_error(
5753 None,
5754 handle.node_id(),
5755 NodeKind::NonTerminal(handle.kind()),
5756 error,
5757 tree,
5758 );
5759 }
5760 };
5761 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5762 let result = match handle
5763 .get_view_with_visit(
5764 tree,
5765 |view, visit: &mut Self| (visit.visit_delim_code_3(handle, view, tree), visit),
5766 self,
5767 )
5768 .map_err(|e| e.extract_error())
5769 {
5770 Ok(Ok(())) => Ok(()),
5771 Ok(Err(e)) => Err(e),
5772 Err(Ok(e)) => Err(e),
5773 Err(Err(e)) => self.then_construct_error(
5774 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5775 handle.node_id(),
5776 NodeKind::NonTerminal(handle.kind()),
5777 e,
5778 tree,
5779 ),
5780 };
5781 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5782 result
5783 }
5784 fn visit_delim_code_3_list_handle(
5785 &mut self,
5786 handle: DelimCode3ListHandle,
5787 tree: &F,
5788 ) -> Result<(), V::Error> {
5789 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5790 Ok(nt_data) => nt_data,
5791 Err(error) => {
5792 return self.then_construct_error(
5793 None,
5794 handle.node_id(),
5795 NodeKind::NonTerminal(handle.kind()),
5796 error,
5797 tree,
5798 );
5799 }
5800 };
5801 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5802 let result = match handle
5803 .get_view_with_visit(
5804 tree,
5805 |view, visit: &mut Self| {
5806 (
5807 if let Some(view) = view {
5808 visit.visit_delim_code_3_list(handle, view, tree)
5809 } else {
5810 Ok(())
5811 },
5812 visit,
5813 )
5814 },
5815 self,
5816 )
5817 .map_err(|e| e.extract_error())
5818 {
5819 Ok(Ok(())) => Ok(()),
5820 Ok(Err(e)) => Err(e),
5821 Err(Ok(e)) => Err(e),
5822 Err(Err(e)) => self.then_construct_error(
5823 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5824 handle.node_id(),
5825 NodeKind::NonTerminal(handle.kind()),
5826 e,
5827 tree,
5828 ),
5829 };
5830 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5831 result
5832 }
5833 fn visit_delim_code_3_list_group_handle(
5834 &mut self,
5835 handle: DelimCode3ListGroupHandle,
5836 tree: &F,
5837 ) -> Result<(), V::Error> {
5838 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5839 Ok(nt_data) => nt_data,
5840 Err(error) => {
5841 return self.then_construct_error(
5842 None,
5843 handle.node_id(),
5844 NodeKind::NonTerminal(handle.kind()),
5845 error,
5846 tree,
5847 );
5848 }
5849 };
5850 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5851 let result = match handle
5852 .get_view_with_visit(
5853 tree,
5854 |view, visit: &mut Self| {
5855 (
5856 visit.visit_delim_code_3_list_group(handle, view, tree),
5857 visit,
5858 )
5859 },
5860 self,
5861 )
5862 .map_err(|e| e.extract_error())
5863 {
5864 Ok(Ok(())) => Ok(()),
5865 Ok(Err(e)) => Err(e),
5866 Err(Ok(e)) => Err(e),
5867 Err(Err(e)) => self.then_construct_error(
5868 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5869 handle.node_id(),
5870 NodeKind::NonTerminal(handle.kind()),
5871 e,
5872 tree,
5873 ),
5874 };
5875 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5876 result
5877 }
5878 fn visit_delim_code_end_1_handle(
5879 &mut self,
5880 handle: DelimCodeEnd1Handle,
5881 tree: &F,
5882 ) -> Result<(), V::Error> {
5883 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5884 Ok(nt_data) => nt_data,
5885 Err(error) => {
5886 return self.then_construct_error(
5887 None,
5888 handle.node_id(),
5889 NodeKind::NonTerminal(handle.kind()),
5890 error,
5891 tree,
5892 );
5893 }
5894 };
5895 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5896 let result = match handle
5897 .get_view_with_visit(
5898 tree,
5899 |view, visit: &mut Self| (visit.visit_delim_code_end_1(handle, view, tree), visit),
5900 self,
5901 )
5902 .map_err(|e| e.extract_error())
5903 {
5904 Ok(Ok(())) => Ok(()),
5905 Ok(Err(e)) => Err(e),
5906 Err(Ok(e)) => Err(e),
5907 Err(Err(e)) => self.then_construct_error(
5908 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5909 handle.node_id(),
5910 NodeKind::NonTerminal(handle.kind()),
5911 e,
5912 tree,
5913 ),
5914 };
5915 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5916 result
5917 }
5918 fn visit_delim_code_end_2_handle(
5919 &mut self,
5920 handle: DelimCodeEnd2Handle,
5921 tree: &F,
5922 ) -> Result<(), V::Error> {
5923 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5924 Ok(nt_data) => nt_data,
5925 Err(error) => {
5926 return self.then_construct_error(
5927 None,
5928 handle.node_id(),
5929 NodeKind::NonTerminal(handle.kind()),
5930 error,
5931 tree,
5932 );
5933 }
5934 };
5935 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5936 let result = match handle
5937 .get_view_with_visit(
5938 tree,
5939 |view, visit: &mut Self| (visit.visit_delim_code_end_2(handle, view, tree), visit),
5940 self,
5941 )
5942 .map_err(|e| e.extract_error())
5943 {
5944 Ok(Ok(())) => Ok(()),
5945 Ok(Err(e)) => Err(e),
5946 Err(Ok(e)) => Err(e),
5947 Err(Err(e)) => self.then_construct_error(
5948 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5949 handle.node_id(),
5950 NodeKind::NonTerminal(handle.kind()),
5951 e,
5952 tree,
5953 ),
5954 };
5955 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5956 result
5957 }
5958 fn visit_delim_code_end_3_handle(
5959 &mut self,
5960 handle: DelimCodeEnd3Handle,
5961 tree: &F,
5962 ) -> Result<(), V::Error> {
5963 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
5964 Ok(nt_data) => nt_data,
5965 Err(error) => {
5966 return self.then_construct_error(
5967 None,
5968 handle.node_id(),
5969 NodeKind::NonTerminal(handle.kind()),
5970 error,
5971 tree,
5972 );
5973 }
5974 };
5975 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
5976 let result = match handle
5977 .get_view_with_visit(
5978 tree,
5979 |view, visit: &mut Self| (visit.visit_delim_code_end_3(handle, view, tree), visit),
5980 self,
5981 )
5982 .map_err(|e| e.extract_error())
5983 {
5984 Ok(Ok(())) => Ok(()),
5985 Ok(Err(e)) => Err(e),
5986 Err(Ok(e)) => Err(e),
5987 Err(Err(e)) => self.then_construct_error(
5988 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
5989 handle.node_id(),
5990 NodeKind::NonTerminal(handle.kind()),
5991 e,
5992 tree,
5993 ),
5994 };
5995 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
5996 result
5997 }
5998 fn visit_delim_code_start_1_handle(
5999 &mut self,
6000 handle: DelimCodeStart1Handle,
6001 tree: &F,
6002 ) -> Result<(), V::Error> {
6003 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6004 Ok(nt_data) => nt_data,
6005 Err(error) => {
6006 return self.then_construct_error(
6007 None,
6008 handle.node_id(),
6009 NodeKind::NonTerminal(handle.kind()),
6010 error,
6011 tree,
6012 );
6013 }
6014 };
6015 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6016 let result = match handle
6017 .get_view_with_visit(
6018 tree,
6019 |view, visit: &mut Self| {
6020 (visit.visit_delim_code_start_1(handle, view, tree), visit)
6021 },
6022 self,
6023 )
6024 .map_err(|e| e.extract_error())
6025 {
6026 Ok(Ok(())) => Ok(()),
6027 Ok(Err(e)) => Err(e),
6028 Err(Ok(e)) => Err(e),
6029 Err(Err(e)) => self.then_construct_error(
6030 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6031 handle.node_id(),
6032 NodeKind::NonTerminal(handle.kind()),
6033 e,
6034 tree,
6035 ),
6036 };
6037 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6038 result
6039 }
6040 fn visit_delim_code_start_2_handle(
6041 &mut self,
6042 handle: DelimCodeStart2Handle,
6043 tree: &F,
6044 ) -> Result<(), V::Error> {
6045 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6046 Ok(nt_data) => nt_data,
6047 Err(error) => {
6048 return self.then_construct_error(
6049 None,
6050 handle.node_id(),
6051 NodeKind::NonTerminal(handle.kind()),
6052 error,
6053 tree,
6054 );
6055 }
6056 };
6057 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6058 let result = match handle
6059 .get_view_with_visit(
6060 tree,
6061 |view, visit: &mut Self| {
6062 (visit.visit_delim_code_start_2(handle, view, tree), visit)
6063 },
6064 self,
6065 )
6066 .map_err(|e| e.extract_error())
6067 {
6068 Ok(Ok(())) => Ok(()),
6069 Ok(Err(e)) => Err(e),
6070 Err(Ok(e)) => Err(e),
6071 Err(Err(e)) => self.then_construct_error(
6072 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6073 handle.node_id(),
6074 NodeKind::NonTerminal(handle.kind()),
6075 e,
6076 tree,
6077 ),
6078 };
6079 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6080 result
6081 }
6082 fn visit_delim_code_start_3_handle(
6083 &mut self,
6084 handle: DelimCodeStart3Handle,
6085 tree: &F,
6086 ) -> Result<(), V::Error> {
6087 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6088 Ok(nt_data) => nt_data,
6089 Err(error) => {
6090 return self.then_construct_error(
6091 None,
6092 handle.node_id(),
6093 NodeKind::NonTerminal(handle.kind()),
6094 error,
6095 tree,
6096 );
6097 }
6098 };
6099 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6100 let result = match handle
6101 .get_view_with_visit(
6102 tree,
6103 |view, visit: &mut Self| {
6104 (visit.visit_delim_code_start_3(handle, view, tree), visit)
6105 },
6106 self,
6107 )
6108 .map_err(|e| e.extract_error())
6109 {
6110 Ok(Ok(())) => Ok(()),
6111 Ok(Err(e)) => Err(e),
6112 Err(Ok(e)) => Err(e),
6113 Err(Err(e)) => self.then_construct_error(
6114 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6115 handle.node_id(),
6116 NodeKind::NonTerminal(handle.kind()),
6117 e,
6118 tree,
6119 ),
6120 };
6121 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6122 result
6123 }
6124 fn visit_dot_handle(&mut self, handle: DotHandle, tree: &F) -> Result<(), V::Error> {
6125 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6126 Ok(nt_data) => nt_data,
6127 Err(error) => {
6128 return self.then_construct_error(
6129 None,
6130 handle.node_id(),
6131 NodeKind::NonTerminal(handle.kind()),
6132 error,
6133 tree,
6134 );
6135 }
6136 };
6137 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6138 let result = match handle
6139 .get_view_with_visit(
6140 tree,
6141 |view, visit: &mut Self| (visit.visit_dot(handle, view, tree), visit),
6142 self,
6143 )
6144 .map_err(|e| e.extract_error())
6145 {
6146 Ok(Ok(())) => Ok(()),
6147 Ok(Err(e)) => Err(e),
6148 Err(Ok(e)) => Err(e),
6149 Err(Err(e)) => self.then_construct_error(
6150 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6151 handle.node_id(),
6152 NodeKind::NonTerminal(handle.kind()),
6153 e,
6154 tree,
6155 ),
6156 };
6157 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6158 result
6159 }
6160 fn visit_dot_key_handle(&mut self, handle: DotKeyHandle, tree: &F) -> Result<(), V::Error> {
6161 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6162 Ok(nt_data) => nt_data,
6163 Err(error) => {
6164 return self.then_construct_error(
6165 None,
6166 handle.node_id(),
6167 NodeKind::NonTerminal(handle.kind()),
6168 error,
6169 tree,
6170 );
6171 }
6172 };
6173 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6174 let result = match handle
6175 .get_view_with_visit(
6176 tree,
6177 |view, visit: &mut Self| (visit.visit_dot_key(handle, view, tree), visit),
6178 self,
6179 )
6180 .map_err(|e| e.extract_error())
6181 {
6182 Ok(Ok(())) => Ok(()),
6183 Ok(Err(e)) => Err(e),
6184 Err(Ok(e)) => Err(e),
6185 Err(Err(e)) => self.then_construct_error(
6186 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6187 handle.node_id(),
6188 NodeKind::NonTerminal(handle.kind()),
6189 e,
6190 tree,
6191 ),
6192 };
6193 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6194 result
6195 }
6196 fn visit_end_handle(&mut self, handle: EndHandle, tree: &F) -> Result<(), V::Error> {
6197 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6198 Ok(nt_data) => nt_data,
6199 Err(error) => {
6200 return self.then_construct_error(
6201 None,
6202 handle.node_id(),
6203 NodeKind::NonTerminal(handle.kind()),
6204 error,
6205 tree,
6206 );
6207 }
6208 };
6209 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6210 let result = match handle
6211 .get_view_with_visit(
6212 tree,
6213 |view, visit: &mut Self| (visit.visit_end(handle, view, tree), visit),
6214 self,
6215 )
6216 .map_err(|e| e.extract_error())
6217 {
6218 Ok(Ok(())) => Ok(()),
6219 Ok(Err(e)) => Err(e),
6220 Err(Ok(e)) => Err(e),
6221 Err(Err(e)) => self.then_construct_error(
6222 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6223 handle.node_id(),
6224 NodeKind::NonTerminal(handle.kind()),
6225 e,
6226 tree,
6227 ),
6228 };
6229 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6230 result
6231 }
6232 fn visit_eure_handle(&mut self, handle: EureHandle, tree: &F) -> 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| (visit.visit_eure(handle, view, tree), visit),
6250 self,
6251 )
6252 .map_err(|e| e.extract_error())
6253 {
6254 Ok(Ok(())) => Ok(()),
6255 Ok(Err(e)) => Err(e),
6256 Err(Ok(e)) => Err(e),
6257 Err(Err(e)) => self.then_construct_error(
6258 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6259 handle.node_id(),
6260 NodeKind::NonTerminal(handle.kind()),
6261 e,
6262 tree,
6263 ),
6264 };
6265 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6266 result
6267 }
6268 fn visit_eure_bindings_handle(
6269 &mut self,
6270 handle: EureBindingsHandle,
6271 tree: &F,
6272 ) -> Result<(), V::Error> {
6273 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6274 Ok(nt_data) => nt_data,
6275 Err(error) => {
6276 return self.then_construct_error(
6277 None,
6278 handle.node_id(),
6279 NodeKind::NonTerminal(handle.kind()),
6280 error,
6281 tree,
6282 );
6283 }
6284 };
6285 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6286 let result = match handle
6287 .get_view_with_visit(
6288 tree,
6289 |view, visit: &mut Self| {
6290 (
6291 if let Some(view) = view {
6292 visit.visit_eure_bindings(handle, view, tree)
6293 } else {
6294 Ok(())
6295 },
6296 visit,
6297 )
6298 },
6299 self,
6300 )
6301 .map_err(|e| e.extract_error())
6302 {
6303 Ok(Ok(())) => Ok(()),
6304 Ok(Err(e)) => Err(e),
6305 Err(Ok(e)) => Err(e),
6306 Err(Err(e)) => self.then_construct_error(
6307 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6308 handle.node_id(),
6309 NodeKind::NonTerminal(handle.kind()),
6310 e,
6311 tree,
6312 ),
6313 };
6314 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6315 result
6316 }
6317 fn visit_eure_sections_handle(
6318 &mut self,
6319 handle: EureSectionsHandle,
6320 tree: &F,
6321 ) -> Result<(), V::Error> {
6322 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6323 Ok(nt_data) => nt_data,
6324 Err(error) => {
6325 return self.then_construct_error(
6326 None,
6327 handle.node_id(),
6328 NodeKind::NonTerminal(handle.kind()),
6329 error,
6330 tree,
6331 );
6332 }
6333 };
6334 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6335 let result = match handle
6336 .get_view_with_visit(
6337 tree,
6338 |view, visit: &mut Self| {
6339 (
6340 if let Some(view) = view {
6341 visit.visit_eure_sections(handle, view, tree)
6342 } else {
6343 Ok(())
6344 },
6345 visit,
6346 )
6347 },
6348 self,
6349 )
6350 .map_err(|e| e.extract_error())
6351 {
6352 Ok(Ok(())) => Ok(()),
6353 Ok(Err(e)) => Err(e),
6354 Err(Ok(e)) => Err(e),
6355 Err(Err(e)) => self.then_construct_error(
6356 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6357 handle.node_id(),
6358 NodeKind::NonTerminal(handle.kind()),
6359 e,
6360 tree,
6361 ),
6362 };
6363 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6364 result
6365 }
6366 fn visit_eure_opt_handle(&mut self, handle: EureOptHandle, tree: &F) -> Result<(), V::Error> {
6367 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6368 Ok(nt_data) => nt_data,
6369 Err(error) => {
6370 return self.then_construct_error(
6371 None,
6372 handle.node_id(),
6373 NodeKind::NonTerminal(handle.kind()),
6374 error,
6375 tree,
6376 );
6377 }
6378 };
6379 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6380 let result = match handle
6381 .get_view_with_visit(
6382 tree,
6383 |view, visit: &mut Self| {
6384 (
6385 if let Some(view) = view {
6386 visit.visit_eure_opt(handle, view, tree)
6387 } else {
6388 Ok(())
6389 },
6390 visit,
6391 )
6392 },
6393 self,
6394 )
6395 .map_err(|e| e.extract_error())
6396 {
6397 Ok(Ok(())) => Ok(()),
6398 Ok(Err(e)) => Err(e),
6399 Err(Ok(e)) => Err(e),
6400 Err(Err(e)) => self.then_construct_error(
6401 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6402 handle.node_id(),
6403 NodeKind::NonTerminal(handle.kind()),
6404 e,
6405 tree,
6406 ),
6407 };
6408 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6409 result
6410 }
6411 fn visit_ext_handle(&mut self, handle: ExtHandle, tree: &F) -> Result<(), V::Error> {
6412 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6413 Ok(nt_data) => nt_data,
6414 Err(error) => {
6415 return self.then_construct_error(
6416 None,
6417 handle.node_id(),
6418 NodeKind::NonTerminal(handle.kind()),
6419 error,
6420 tree,
6421 );
6422 }
6423 };
6424 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6425 let result = match handle
6426 .get_view_with_visit(
6427 tree,
6428 |view, visit: &mut Self| (visit.visit_ext(handle, view, tree), visit),
6429 self,
6430 )
6431 .map_err(|e| e.extract_error())
6432 {
6433 Ok(Ok(())) => Ok(()),
6434 Ok(Err(e)) => Err(e),
6435 Err(Ok(e)) => Err(e),
6436 Err(Err(e)) => self.then_construct_error(
6437 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6438 handle.node_id(),
6439 NodeKind::NonTerminal(handle.kind()),
6440 e,
6441 tree,
6442 ),
6443 };
6444 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6445 result
6446 }
6447 fn visit_extension_name_space_handle(
6448 &mut self,
6449 handle: ExtensionNameSpaceHandle,
6450 tree: &F,
6451 ) -> Result<(), V::Error> {
6452 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6453 Ok(nt_data) => nt_data,
6454 Err(error) => {
6455 return self.then_construct_error(
6456 None,
6457 handle.node_id(),
6458 NodeKind::NonTerminal(handle.kind()),
6459 error,
6460 tree,
6461 );
6462 }
6463 };
6464 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6465 let result = match handle
6466 .get_view_with_visit(
6467 tree,
6468 |view, visit: &mut Self| {
6469 (visit.visit_extension_name_space(handle, view, tree), visit)
6470 },
6471 self,
6472 )
6473 .map_err(|e| e.extract_error())
6474 {
6475 Ok(Ok(())) => Ok(()),
6476 Ok(Err(e)) => Err(e),
6477 Err(Ok(e)) => Err(e),
6478 Err(Err(e)) => self.then_construct_error(
6479 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6480 handle.node_id(),
6481 NodeKind::NonTerminal(handle.kind()),
6482 e,
6483 tree,
6484 ),
6485 };
6486 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6487 result
6488 }
6489 fn visit_false_handle(&mut self, handle: FalseHandle, tree: &F) -> Result<(), V::Error> {
6490 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6491 Ok(nt_data) => nt_data,
6492 Err(error) => {
6493 return self.then_construct_error(
6494 None,
6495 handle.node_id(),
6496 NodeKind::NonTerminal(handle.kind()),
6497 error,
6498 tree,
6499 );
6500 }
6501 };
6502 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6503 let result = match handle
6504 .get_view_with_visit(
6505 tree,
6506 |view, visit: &mut Self| (visit.visit_false(handle, view, tree), visit),
6507 self,
6508 )
6509 .map_err(|e| e.extract_error())
6510 {
6511 Ok(Ok(())) => Ok(()),
6512 Ok(Err(e)) => Err(e),
6513 Err(Ok(e)) => Err(e),
6514 Err(Err(e)) => self.then_construct_error(
6515 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6516 handle.node_id(),
6517 NodeKind::NonTerminal(handle.kind()),
6518 e,
6519 tree,
6520 ),
6521 };
6522 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6523 result
6524 }
6525 fn visit_first_key_handle(&mut self, handle: FirstKeyHandle, tree: &F) -> Result<(), V::Error> {
6526 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6527 Ok(nt_data) => nt_data,
6528 Err(error) => {
6529 return self.then_construct_error(
6530 None,
6531 handle.node_id(),
6532 NodeKind::NonTerminal(handle.kind()),
6533 error,
6534 tree,
6535 );
6536 }
6537 };
6538 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6539 let result = match handle
6540 .get_view_with_visit(
6541 tree,
6542 |view, visit: &mut Self| (visit.visit_first_key(handle, view, tree), visit),
6543 self,
6544 )
6545 .map_err(|e| e.extract_error())
6546 {
6547 Ok(Ok(())) => Ok(()),
6548 Ok(Err(e)) => Err(e),
6549 Err(Ok(e)) => Err(e),
6550 Err(Err(e)) => self.then_construct_error(
6551 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6552 handle.node_id(),
6553 NodeKind::NonTerminal(handle.kind()),
6554 e,
6555 tree,
6556 ),
6557 };
6558 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6559 result
6560 }
6561 fn visit_flat_body_handle(&mut self, handle: FlatBodyHandle, tree: &F) -> Result<(), V::Error> {
6562 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6563 Ok(nt_data) => nt_data,
6564 Err(error) => {
6565 return self.then_construct_error(
6566 None,
6567 handle.node_id(),
6568 NodeKind::NonTerminal(handle.kind()),
6569 error,
6570 tree,
6571 );
6572 }
6573 };
6574 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6575 let result = match handle
6576 .get_view_with_visit(
6577 tree,
6578 |view, visit: &mut Self| (visit.visit_flat_body(handle, view, tree), visit),
6579 self,
6580 )
6581 .map_err(|e| e.extract_error())
6582 {
6583 Ok(Ok(())) => Ok(()),
6584 Ok(Err(e)) => Err(e),
6585 Err(Ok(e)) => Err(e),
6586 Err(Err(e)) => self.then_construct_error(
6587 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6588 handle.node_id(),
6589 NodeKind::NonTerminal(handle.kind()),
6590 e,
6591 tree,
6592 ),
6593 };
6594 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6595 result
6596 }
6597 fn visit_flat_body_list_handle(
6598 &mut self,
6599 handle: FlatBodyListHandle,
6600 tree: &F,
6601 ) -> Result<(), V::Error> {
6602 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6603 Ok(nt_data) => nt_data,
6604 Err(error) => {
6605 return self.then_construct_error(
6606 None,
6607 handle.node_id(),
6608 NodeKind::NonTerminal(handle.kind()),
6609 error,
6610 tree,
6611 );
6612 }
6613 };
6614 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6615 let result = match handle
6616 .get_view_with_visit(
6617 tree,
6618 |view, visit: &mut Self| {
6619 (
6620 if let Some(view) = view {
6621 visit.visit_flat_body_list(handle, view, tree)
6622 } else {
6623 Ok(())
6624 },
6625 visit,
6626 )
6627 },
6628 self,
6629 )
6630 .map_err(|e| e.extract_error())
6631 {
6632 Ok(Ok(())) => Ok(()),
6633 Ok(Err(e)) => Err(e),
6634 Err(Ok(e)) => Err(e),
6635 Err(Err(e)) => self.then_construct_error(
6636 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6637 handle.node_id(),
6638 NodeKind::NonTerminal(handle.kind()),
6639 e,
6640 tree,
6641 ),
6642 };
6643 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6644 result
6645 }
6646 fn visit_flat_root_binding_handle(
6647 &mut self,
6648 handle: FlatRootBindingHandle,
6649 tree: &F,
6650 ) -> Result<(), V::Error> {
6651 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6652 Ok(nt_data) => nt_data,
6653 Err(error) => {
6654 return self.then_construct_error(
6655 None,
6656 handle.node_id(),
6657 NodeKind::NonTerminal(handle.kind()),
6658 error,
6659 tree,
6660 );
6661 }
6662 };
6663 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6664 let result = match handle
6665 .get_view_with_visit(
6666 tree,
6667 |view, visit: &mut Self| (visit.visit_flat_root_binding(handle, view, tree), visit),
6668 self,
6669 )
6670 .map_err(|e| e.extract_error())
6671 {
6672 Ok(Ok(())) => Ok(()),
6673 Ok(Err(e)) => Err(e),
6674 Err(Ok(e)) => Err(e),
6675 Err(Err(e)) => self.then_construct_error(
6676 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6677 handle.node_id(),
6678 NodeKind::NonTerminal(handle.kind()),
6679 e,
6680 tree,
6681 ),
6682 };
6683 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6684 result
6685 }
6686 fn visit_float_handle(&mut self, handle: FloatHandle, tree: &F) -> Result<(), V::Error> {
6687 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6688 Ok(nt_data) => nt_data,
6689 Err(error) => {
6690 return self.then_construct_error(
6691 None,
6692 handle.node_id(),
6693 NodeKind::NonTerminal(handle.kind()),
6694 error,
6695 tree,
6696 );
6697 }
6698 };
6699 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6700 let result = match handle
6701 .get_view_with_visit(
6702 tree,
6703 |view, visit: &mut Self| (visit.visit_float(handle, view, tree), visit),
6704 self,
6705 )
6706 .map_err(|e| e.extract_error())
6707 {
6708 Ok(Ok(())) => Ok(()),
6709 Ok(Err(e)) => Err(e),
6710 Err(Ok(e)) => Err(e),
6711 Err(Err(e)) => self.then_construct_error(
6712 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6713 handle.node_id(),
6714 NodeKind::NonTerminal(handle.kind()),
6715 e,
6716 tree,
6717 ),
6718 };
6719 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6720 result
6721 }
6722 fn visit_grammar_newline_handle(
6723 &mut self,
6724 handle: GrammarNewlineHandle,
6725 tree: &F,
6726 ) -> Result<(), V::Error> {
6727 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6728 Ok(nt_data) => nt_data,
6729 Err(error) => {
6730 return self.then_construct_error(
6731 None,
6732 handle.node_id(),
6733 NodeKind::NonTerminal(handle.kind()),
6734 error,
6735 tree,
6736 );
6737 }
6738 };
6739 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6740 let result = match handle
6741 .get_view_with_visit(
6742 tree,
6743 |view, visit: &mut Self| (visit.visit_grammar_newline(handle, view, tree), visit),
6744 self,
6745 )
6746 .map_err(|e| e.extract_error())
6747 {
6748 Ok(Ok(())) => Ok(()),
6749 Ok(Err(e)) => Err(e),
6750 Err(Ok(e)) => Err(e),
6751 Err(Err(e)) => self.then_construct_error(
6752 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6753 handle.node_id(),
6754 NodeKind::NonTerminal(handle.kind()),
6755 e,
6756 tree,
6757 ),
6758 };
6759 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6760 result
6761 }
6762 fn visit_hole_handle(&mut self, handle: HoleHandle, tree: &F) -> Result<(), V::Error> {
6763 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6764 Ok(nt_data) => nt_data,
6765 Err(error) => {
6766 return self.then_construct_error(
6767 None,
6768 handle.node_id(),
6769 NodeKind::NonTerminal(handle.kind()),
6770 error,
6771 tree,
6772 );
6773 }
6774 };
6775 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6776 let result = match handle
6777 .get_view_with_visit(
6778 tree,
6779 |view, visit: &mut Self| (visit.visit_hole(handle, view, tree), visit),
6780 self,
6781 )
6782 .map_err(|e| e.extract_error())
6783 {
6784 Ok(Ok(())) => Ok(()),
6785 Ok(Err(e)) => Err(e),
6786 Err(Ok(e)) => Err(e),
6787 Err(Err(e)) => self.then_construct_error(
6788 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6789 handle.node_id(),
6790 NodeKind::NonTerminal(handle.kind()),
6791 e,
6792 tree,
6793 ),
6794 };
6795 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6796 result
6797 }
6798 fn visit_ident_handle(&mut self, handle: IdentHandle, tree: &F) -> Result<(), V::Error> {
6799 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6800 Ok(nt_data) => nt_data,
6801 Err(error) => {
6802 return self.then_construct_error(
6803 None,
6804 handle.node_id(),
6805 NodeKind::NonTerminal(handle.kind()),
6806 error,
6807 tree,
6808 );
6809 }
6810 };
6811 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6812 let result = match handle
6813 .get_view_with_visit(
6814 tree,
6815 |view, visit: &mut Self| (visit.visit_ident(handle, view, tree), visit),
6816 self,
6817 )
6818 .map_err(|e| e.extract_error())
6819 {
6820 Ok(Ok(())) => Ok(()),
6821 Ok(Err(e)) => Err(e),
6822 Err(Ok(e)) => Err(e),
6823 Err(Err(e)) => self.then_construct_error(
6824 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6825 handle.node_id(),
6826 NodeKind::NonTerminal(handle.kind()),
6827 e,
6828 tree,
6829 ),
6830 };
6831 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6832 result
6833 }
6834 fn visit_inf_handle(&mut self, handle: InfHandle, tree: &F) -> Result<(), V::Error> {
6835 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6836 Ok(nt_data) => nt_data,
6837 Err(error) => {
6838 return self.then_construct_error(
6839 None,
6840 handle.node_id(),
6841 NodeKind::NonTerminal(handle.kind()),
6842 error,
6843 tree,
6844 );
6845 }
6846 };
6847 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6848 let result = match handle
6849 .get_view_with_visit(
6850 tree,
6851 |view, visit: &mut Self| (visit.visit_inf(handle, view, tree), visit),
6852 self,
6853 )
6854 .map_err(|e| e.extract_error())
6855 {
6856 Ok(Ok(())) => Ok(()),
6857 Ok(Err(e)) => Err(e),
6858 Err(Ok(e)) => Err(e),
6859 Err(Err(e)) => self.then_construct_error(
6860 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6861 handle.node_id(),
6862 NodeKind::NonTerminal(handle.kind()),
6863 e,
6864 tree,
6865 ),
6866 };
6867 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6868 result
6869 }
6870 fn visit_inline_code_handle(
6871 &mut self,
6872 handle: InlineCodeHandle,
6873 tree: &F,
6874 ) -> Result<(), V::Error> {
6875 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6876 Ok(nt_data) => nt_data,
6877 Err(error) => {
6878 return self.then_construct_error(
6879 None,
6880 handle.node_id(),
6881 NodeKind::NonTerminal(handle.kind()),
6882 error,
6883 tree,
6884 );
6885 }
6886 };
6887 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6888 let result = match handle
6889 .get_view_with_visit(
6890 tree,
6891 |view, visit: &mut Self| (visit.visit_inline_code(handle, view, tree), visit),
6892 self,
6893 )
6894 .map_err(|e| e.extract_error())
6895 {
6896 Ok(Ok(())) => Ok(()),
6897 Ok(Err(e)) => Err(e),
6898 Err(Ok(e)) => Err(e),
6899 Err(Err(e)) => self.then_construct_error(
6900 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6901 handle.node_id(),
6902 NodeKind::NonTerminal(handle.kind()),
6903 e,
6904 tree,
6905 ),
6906 };
6907 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6908 result
6909 }
6910 fn visit_inline_code_1_handle(
6911 &mut self,
6912 handle: InlineCode1Handle,
6913 tree: &F,
6914 ) -> Result<(), V::Error> {
6915 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6916 Ok(nt_data) => nt_data,
6917 Err(error) => {
6918 return self.then_construct_error(
6919 None,
6920 handle.node_id(),
6921 NodeKind::NonTerminal(handle.kind()),
6922 error,
6923 tree,
6924 );
6925 }
6926 };
6927 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6928 let result = match handle
6929 .get_view_with_visit(
6930 tree,
6931 |view, visit: &mut Self| (visit.visit_inline_code_1(handle, view, tree), visit),
6932 self,
6933 )
6934 .map_err(|e| e.extract_error())
6935 {
6936 Ok(Ok(())) => Ok(()),
6937 Ok(Err(e)) => Err(e),
6938 Err(Ok(e)) => Err(e),
6939 Err(Err(e)) => self.then_construct_error(
6940 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6941 handle.node_id(),
6942 NodeKind::NonTerminal(handle.kind()),
6943 e,
6944 tree,
6945 ),
6946 };
6947 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6948 result
6949 }
6950 fn visit_integer_handle(&mut self, handle: IntegerHandle, tree: &F) -> Result<(), V::Error> {
6951 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6952 Ok(nt_data) => nt_data,
6953 Err(error) => {
6954 return self.then_construct_error(
6955 None,
6956 handle.node_id(),
6957 NodeKind::NonTerminal(handle.kind()),
6958 error,
6959 tree,
6960 );
6961 }
6962 };
6963 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
6964 let result = match handle
6965 .get_view_with_visit(
6966 tree,
6967 |view, visit: &mut Self| (visit.visit_integer(handle, view, tree), visit),
6968 self,
6969 )
6970 .map_err(|e| e.extract_error())
6971 {
6972 Ok(Ok(())) => Ok(()),
6973 Ok(Err(e)) => Err(e),
6974 Err(Ok(e)) => Err(e),
6975 Err(Err(e)) => self.then_construct_error(
6976 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
6977 handle.node_id(),
6978 NodeKind::NonTerminal(handle.kind()),
6979 e,
6980 tree,
6981 ),
6982 };
6983 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
6984 result
6985 }
6986 fn visit_key_handle(&mut self, handle: KeyHandle, tree: &F) -> Result<(), V::Error> {
6987 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
6988 Ok(nt_data) => nt_data,
6989 Err(error) => {
6990 return self.then_construct_error(
6991 None,
6992 handle.node_id(),
6993 NodeKind::NonTerminal(handle.kind()),
6994 error,
6995 tree,
6996 );
6997 }
6998 };
6999 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7000 let result = match handle
7001 .get_view_with_visit(
7002 tree,
7003 |view, visit: &mut Self| (visit.visit_key(handle, view, tree), visit),
7004 self,
7005 )
7006 .map_err(|e| e.extract_error())
7007 {
7008 Ok(Ok(())) => Ok(()),
7009 Ok(Err(e)) => Err(e),
7010 Err(Ok(e)) => Err(e),
7011 Err(Err(e)) => self.then_construct_error(
7012 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7013 handle.node_id(),
7014 NodeKind::NonTerminal(handle.kind()),
7015 e,
7016 tree,
7017 ),
7018 };
7019 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7020 result
7021 }
7022 fn visit_key_ident_handle(&mut self, handle: KeyIdentHandle, tree: &F) -> Result<(), V::Error> {
7023 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7024 Ok(nt_data) => nt_data,
7025 Err(error) => {
7026 return self.then_construct_error(
7027 None,
7028 handle.node_id(),
7029 NodeKind::NonTerminal(handle.kind()),
7030 error,
7031 tree,
7032 );
7033 }
7034 };
7035 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7036 let result = match handle
7037 .get_view_with_visit(
7038 tree,
7039 |view, visit: &mut Self| (visit.visit_key_ident(handle, view, tree), visit),
7040 self,
7041 )
7042 .map_err(|e| e.extract_error())
7043 {
7044 Ok(Ok(())) => Ok(()),
7045 Ok(Err(e)) => Err(e),
7046 Err(Ok(e)) => Err(e),
7047 Err(Err(e)) => self.then_construct_error(
7048 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7049 handle.node_id(),
7050 NodeKind::NonTerminal(handle.kind()),
7051 e,
7052 tree,
7053 ),
7054 };
7055 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7056 result
7057 }
7058 fn visit_key_tail_handle(&mut self, handle: KeyTailHandle, tree: &F) -> Result<(), V::Error> {
7059 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7060 Ok(nt_data) => nt_data,
7061 Err(error) => {
7062 return self.then_construct_error(
7063 None,
7064 handle.node_id(),
7065 NodeKind::NonTerminal(handle.kind()),
7066 error,
7067 tree,
7068 );
7069 }
7070 };
7071 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7072 let result = match handle
7073 .get_view_with_visit(
7074 tree,
7075 |view, visit: &mut Self| (visit.visit_key_tail(handle, view, tree), visit),
7076 self,
7077 )
7078 .map_err(|e| e.extract_error())
7079 {
7080 Ok(Ok(())) => Ok(()),
7081 Ok(Err(e)) => Err(e),
7082 Err(Ok(e)) => Err(e),
7083 Err(Err(e)) => self.then_construct_error(
7084 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7085 handle.node_id(),
7086 NodeKind::NonTerminal(handle.kind()),
7087 e,
7088 tree,
7089 ),
7090 };
7091 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7092 result
7093 }
7094 fn visit_key_tuple_handle(&mut self, handle: KeyTupleHandle, tree: &F) -> Result<(), V::Error> {
7095 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7096 Ok(nt_data) => nt_data,
7097 Err(error) => {
7098 return self.then_construct_error(
7099 None,
7100 handle.node_id(),
7101 NodeKind::NonTerminal(handle.kind()),
7102 error,
7103 tree,
7104 );
7105 }
7106 };
7107 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7108 let result = match handle
7109 .get_view_with_visit(
7110 tree,
7111 |view, visit: &mut Self| (visit.visit_key_tuple(handle, view, tree), visit),
7112 self,
7113 )
7114 .map_err(|e| e.extract_error())
7115 {
7116 Ok(Ok(())) => Ok(()),
7117 Ok(Err(e)) => Err(e),
7118 Err(Ok(e)) => Err(e),
7119 Err(Err(e)) => self.then_construct_error(
7120 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7121 handle.node_id(),
7122 NodeKind::NonTerminal(handle.kind()),
7123 e,
7124 tree,
7125 ),
7126 };
7127 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7128 result
7129 }
7130 fn visit_key_tuple_elements_handle(
7131 &mut self,
7132 handle: KeyTupleElementsHandle,
7133 tree: &F,
7134 ) -> Result<(), V::Error> {
7135 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7136 Ok(nt_data) => nt_data,
7137 Err(error) => {
7138 return self.then_construct_error(
7139 None,
7140 handle.node_id(),
7141 NodeKind::NonTerminal(handle.kind()),
7142 error,
7143 tree,
7144 );
7145 }
7146 };
7147 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7148 let result = match handle
7149 .get_view_with_visit(
7150 tree,
7151 |view, visit: &mut Self| {
7152 (visit.visit_key_tuple_elements(handle, view, tree), visit)
7153 },
7154 self,
7155 )
7156 .map_err(|e| e.extract_error())
7157 {
7158 Ok(Ok(())) => Ok(()),
7159 Ok(Err(e)) => Err(e),
7160 Err(Ok(e)) => Err(e),
7161 Err(Err(e)) => self.then_construct_error(
7162 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7163 handle.node_id(),
7164 NodeKind::NonTerminal(handle.kind()),
7165 e,
7166 tree,
7167 ),
7168 };
7169 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7170 result
7171 }
7172 fn visit_key_tuple_elements_opt_handle(
7173 &mut self,
7174 handle: KeyTupleElementsOptHandle,
7175 tree: &F,
7176 ) -> Result<(), V::Error> {
7177 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7178 Ok(nt_data) => nt_data,
7179 Err(error) => {
7180 return self.then_construct_error(
7181 None,
7182 handle.node_id(),
7183 NodeKind::NonTerminal(handle.kind()),
7184 error,
7185 tree,
7186 );
7187 }
7188 };
7189 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7190 let result = match handle
7191 .get_view_with_visit(
7192 tree,
7193 |view, visit: &mut Self| {
7194 (
7195 if let Some(view) = view {
7196 visit.visit_key_tuple_elements_opt(handle, view, tree)
7197 } else {
7198 Ok(())
7199 },
7200 visit,
7201 )
7202 },
7203 self,
7204 )
7205 .map_err(|e| e.extract_error())
7206 {
7207 Ok(Ok(())) => Ok(()),
7208 Ok(Err(e)) => Err(e),
7209 Err(Ok(e)) => Err(e),
7210 Err(Err(e)) => self.then_construct_error(
7211 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7212 handle.node_id(),
7213 NodeKind::NonTerminal(handle.kind()),
7214 e,
7215 tree,
7216 ),
7217 };
7218 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7219 result
7220 }
7221 fn visit_key_tuple_elements_tail_handle(
7222 &mut self,
7223 handle: KeyTupleElementsTailHandle,
7224 tree: &F,
7225 ) -> Result<(), V::Error> {
7226 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7227 Ok(nt_data) => nt_data,
7228 Err(error) => {
7229 return self.then_construct_error(
7230 None,
7231 handle.node_id(),
7232 NodeKind::NonTerminal(handle.kind()),
7233 error,
7234 tree,
7235 );
7236 }
7237 };
7238 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7239 let result = match handle
7240 .get_view_with_visit(
7241 tree,
7242 |view, visit: &mut Self| {
7243 (
7244 visit.visit_key_tuple_elements_tail(handle, view, tree),
7245 visit,
7246 )
7247 },
7248 self,
7249 )
7250 .map_err(|e| e.extract_error())
7251 {
7252 Ok(Ok(())) => Ok(()),
7253 Ok(Err(e)) => Err(e),
7254 Err(Ok(e)) => Err(e),
7255 Err(Err(e)) => self.then_construct_error(
7256 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7257 handle.node_id(),
7258 NodeKind::NonTerminal(handle.kind()),
7259 e,
7260 tree,
7261 ),
7262 };
7263 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7264 result
7265 }
7266 fn visit_key_tuple_elements_tail_opt_handle(
7267 &mut self,
7268 handle: KeyTupleElementsTailOptHandle,
7269 tree: &F,
7270 ) -> Result<(), V::Error> {
7271 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7272 Ok(nt_data) => nt_data,
7273 Err(error) => {
7274 return self.then_construct_error(
7275 None,
7276 handle.node_id(),
7277 NodeKind::NonTerminal(handle.kind()),
7278 error,
7279 tree,
7280 );
7281 }
7282 };
7283 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7284 let result = match handle
7285 .get_view_with_visit(
7286 tree,
7287 |view, visit: &mut Self| {
7288 (
7289 if let Some(view) = view {
7290 visit.visit_key_tuple_elements_tail_opt(handle, view, tree)
7291 } else {
7292 Ok(())
7293 },
7294 visit,
7295 )
7296 },
7297 self,
7298 )
7299 .map_err(|e| e.extract_error())
7300 {
7301 Ok(Ok(())) => Ok(()),
7302 Ok(Err(e)) => Err(e),
7303 Err(Ok(e)) => Err(e),
7304 Err(Err(e)) => self.then_construct_error(
7305 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7306 handle.node_id(),
7307 NodeKind::NonTerminal(handle.kind()),
7308 e,
7309 tree,
7310 ),
7311 };
7312 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7313 result
7314 }
7315 fn visit_key_tuple_opt_handle(
7316 &mut self,
7317 handle: KeyTupleOptHandle,
7318 tree: &F,
7319 ) -> Result<(), V::Error> {
7320 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7321 Ok(nt_data) => nt_data,
7322 Err(error) => {
7323 return self.then_construct_error(
7324 None,
7325 handle.node_id(),
7326 NodeKind::NonTerminal(handle.kind()),
7327 error,
7328 tree,
7329 );
7330 }
7331 };
7332 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7333 let result = match handle
7334 .get_view_with_visit(
7335 tree,
7336 |view, visit: &mut Self| {
7337 (
7338 if let Some(view) = view {
7339 visit.visit_key_tuple_opt(handle, view, tree)
7340 } else {
7341 Ok(())
7342 },
7343 visit,
7344 )
7345 },
7346 self,
7347 )
7348 .map_err(|e| e.extract_error())
7349 {
7350 Ok(Ok(())) => Ok(()),
7351 Ok(Err(e)) => Err(e),
7352 Err(Ok(e)) => Err(e),
7353 Err(Err(e)) => self.then_construct_error(
7354 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7355 handle.node_id(),
7356 NodeKind::NonTerminal(handle.kind()),
7357 e,
7358 tree,
7359 ),
7360 };
7361 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7362 result
7363 }
7364 fn visit_key_value_handle(&mut self, handle: KeyValueHandle, tree: &F) -> Result<(), V::Error> {
7365 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7366 Ok(nt_data) => nt_data,
7367 Err(error) => {
7368 return self.then_construct_error(
7369 None,
7370 handle.node_id(),
7371 NodeKind::NonTerminal(handle.kind()),
7372 error,
7373 tree,
7374 );
7375 }
7376 };
7377 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7378 let result = match handle
7379 .get_view_with_visit(
7380 tree,
7381 |view, visit: &mut Self| (visit.visit_key_value(handle, view, tree), visit),
7382 self,
7383 )
7384 .map_err(|e| e.extract_error())
7385 {
7386 Ok(Ok(())) => Ok(()),
7387 Ok(Err(e)) => Err(e),
7388 Err(Ok(e)) => Err(e),
7389 Err(Err(e)) => self.then_construct_error(
7390 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7391 handle.node_id(),
7392 NodeKind::NonTerminal(handle.kind()),
7393 e,
7394 tree,
7395 ),
7396 };
7397 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7398 result
7399 }
7400 fn visit_keys_handle(&mut self, handle: KeysHandle, tree: &F) -> Result<(), V::Error> {
7401 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7402 Ok(nt_data) => nt_data,
7403 Err(error) => {
7404 return self.then_construct_error(
7405 None,
7406 handle.node_id(),
7407 NodeKind::NonTerminal(handle.kind()),
7408 error,
7409 tree,
7410 );
7411 }
7412 };
7413 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7414 let result = match handle
7415 .get_view_with_visit(
7416 tree,
7417 |view, visit: &mut Self| (visit.visit_keys(handle, view, tree), visit),
7418 self,
7419 )
7420 .map_err(|e| e.extract_error())
7421 {
7422 Ok(Ok(())) => Ok(()),
7423 Ok(Err(e)) => Err(e),
7424 Err(Ok(e)) => Err(e),
7425 Err(Err(e)) => self.then_construct_error(
7426 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7427 handle.node_id(),
7428 NodeKind::NonTerminal(handle.kind()),
7429 e,
7430 tree,
7431 ),
7432 };
7433 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7434 result
7435 }
7436 fn visit_keys_list_handle(&mut self, handle: KeysListHandle, tree: &F) -> Result<(), V::Error> {
7437 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7438 Ok(nt_data) => nt_data,
7439 Err(error) => {
7440 return self.then_construct_error(
7441 None,
7442 handle.node_id(),
7443 NodeKind::NonTerminal(handle.kind()),
7444 error,
7445 tree,
7446 );
7447 }
7448 };
7449 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7450 let result = match handle
7451 .get_view_with_visit(
7452 tree,
7453 |view, visit: &mut Self| {
7454 (
7455 if let Some(view) = view {
7456 visit.visit_keys_list(handle, view, tree)
7457 } else {
7458 Ok(())
7459 },
7460 visit,
7461 )
7462 },
7463 self,
7464 )
7465 .map_err(|e| e.extract_error())
7466 {
7467 Ok(Ok(())) => Ok(()),
7468 Ok(Err(e)) => Err(e),
7469 Err(Ok(e)) => Err(e),
7470 Err(Err(e)) => self.then_construct_error(
7471 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7472 handle.node_id(),
7473 NodeKind::NonTerminal(handle.kind()),
7474 e,
7475 tree,
7476 ),
7477 };
7478 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7479 result
7480 }
7481 fn visit_l_paren_handle(&mut self, handle: LParenHandle, tree: &F) -> Result<(), V::Error> {
7482 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7483 Ok(nt_data) => nt_data,
7484 Err(error) => {
7485 return self.then_construct_error(
7486 None,
7487 handle.node_id(),
7488 NodeKind::NonTerminal(handle.kind()),
7489 error,
7490 tree,
7491 );
7492 }
7493 };
7494 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7495 let result = match handle
7496 .get_view_with_visit(
7497 tree,
7498 |view, visit: &mut Self| (visit.visit_l_paren(handle, view, tree), visit),
7499 self,
7500 )
7501 .map_err(|e| e.extract_error())
7502 {
7503 Ok(Ok(())) => Ok(()),
7504 Ok(Err(e)) => Err(e),
7505 Err(Ok(e)) => Err(e),
7506 Err(Err(e)) => self.then_construct_error(
7507 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7508 handle.node_id(),
7509 NodeKind::NonTerminal(handle.kind()),
7510 e,
7511 tree,
7512 ),
7513 };
7514 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7515 result
7516 }
7517 fn visit_lit_str_handle(&mut self, handle: LitStrHandle, tree: &F) -> Result<(), V::Error> {
7518 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7519 Ok(nt_data) => nt_data,
7520 Err(error) => {
7521 return self.then_construct_error(
7522 None,
7523 handle.node_id(),
7524 NodeKind::NonTerminal(handle.kind()),
7525 error,
7526 tree,
7527 );
7528 }
7529 };
7530 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7531 let result = match handle
7532 .get_view_with_visit(
7533 tree,
7534 |view, visit: &mut Self| (visit.visit_lit_str(handle, view, tree), visit),
7535 self,
7536 )
7537 .map_err(|e| e.extract_error())
7538 {
7539 Ok(Ok(())) => Ok(()),
7540 Ok(Err(e)) => Err(e),
7541 Err(Ok(e)) => Err(e),
7542 Err(Err(e)) => self.then_construct_error(
7543 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7544 handle.node_id(),
7545 NodeKind::NonTerminal(handle.kind()),
7546 e,
7547 tree,
7548 ),
7549 };
7550 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7551 result
7552 }
7553 fn visit_lit_str_1_handle(&mut self, handle: LitStr1Handle, tree: &F) -> Result<(), V::Error> {
7554 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7555 Ok(nt_data) => nt_data,
7556 Err(error) => {
7557 return self.then_construct_error(
7558 None,
7559 handle.node_id(),
7560 NodeKind::NonTerminal(handle.kind()),
7561 error,
7562 tree,
7563 );
7564 }
7565 };
7566 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7567 let result = match handle
7568 .get_view_with_visit(
7569 tree,
7570 |view, visit: &mut Self| (visit.visit_lit_str_1(handle, view, tree), visit),
7571 self,
7572 )
7573 .map_err(|e| e.extract_error())
7574 {
7575 Ok(Ok(())) => Ok(()),
7576 Ok(Err(e)) => Err(e),
7577 Err(Ok(e)) => Err(e),
7578 Err(Err(e)) => self.then_construct_error(
7579 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7580 handle.node_id(),
7581 NodeKind::NonTerminal(handle.kind()),
7582 e,
7583 tree,
7584 ),
7585 };
7586 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7587 result
7588 }
7589 fn visit_lit_str_1_end_handle(
7590 &mut self,
7591 handle: LitStr1EndHandle,
7592 tree: &F,
7593 ) -> Result<(), V::Error> {
7594 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7595 Ok(nt_data) => nt_data,
7596 Err(error) => {
7597 return self.then_construct_error(
7598 None,
7599 handle.node_id(),
7600 NodeKind::NonTerminal(handle.kind()),
7601 error,
7602 tree,
7603 );
7604 }
7605 };
7606 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7607 let result = match handle
7608 .get_view_with_visit(
7609 tree,
7610 |view, visit: &mut Self| (visit.visit_lit_str_1_end(handle, view, tree), visit),
7611 self,
7612 )
7613 .map_err(|e| e.extract_error())
7614 {
7615 Ok(Ok(())) => Ok(()),
7616 Ok(Err(e)) => Err(e),
7617 Err(Ok(e)) => Err(e),
7618 Err(Err(e)) => self.then_construct_error(
7619 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7620 handle.node_id(),
7621 NodeKind::NonTerminal(handle.kind()),
7622 e,
7623 tree,
7624 ),
7625 };
7626 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7627 result
7628 }
7629 fn visit_lit_str_1_list_handle(
7630 &mut self,
7631 handle: LitStr1ListHandle,
7632 tree: &F,
7633 ) -> Result<(), V::Error> {
7634 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7635 Ok(nt_data) => nt_data,
7636 Err(error) => {
7637 return self.then_construct_error(
7638 None,
7639 handle.node_id(),
7640 NodeKind::NonTerminal(handle.kind()),
7641 error,
7642 tree,
7643 );
7644 }
7645 };
7646 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7647 let result = match handle
7648 .get_view_with_visit(
7649 tree,
7650 |view, visit: &mut Self| {
7651 (
7652 if let Some(view) = view {
7653 visit.visit_lit_str_1_list(handle, view, tree)
7654 } else {
7655 Ok(())
7656 },
7657 visit,
7658 )
7659 },
7660 self,
7661 )
7662 .map_err(|e| e.extract_error())
7663 {
7664 Ok(Ok(())) => Ok(()),
7665 Ok(Err(e)) => Err(e),
7666 Err(Ok(e)) => Err(e),
7667 Err(Err(e)) => self.then_construct_error(
7668 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7669 handle.node_id(),
7670 NodeKind::NonTerminal(handle.kind()),
7671 e,
7672 tree,
7673 ),
7674 };
7675 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7676 result
7677 }
7678 fn visit_lit_str_1_list_group_handle(
7679 &mut self,
7680 handle: LitStr1ListGroupHandle,
7681 tree: &F,
7682 ) -> Result<(), V::Error> {
7683 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7684 Ok(nt_data) => nt_data,
7685 Err(error) => {
7686 return self.then_construct_error(
7687 None,
7688 handle.node_id(),
7689 NodeKind::NonTerminal(handle.kind()),
7690 error,
7691 tree,
7692 );
7693 }
7694 };
7695 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7696 let result = match handle
7697 .get_view_with_visit(
7698 tree,
7699 |view, visit: &mut Self| {
7700 (visit.visit_lit_str_1_list_group(handle, view, tree), visit)
7701 },
7702 self,
7703 )
7704 .map_err(|e| e.extract_error())
7705 {
7706 Ok(Ok(())) => Ok(()),
7707 Ok(Err(e)) => Err(e),
7708 Err(Ok(e)) => Err(e),
7709 Err(Err(e)) => self.then_construct_error(
7710 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7711 handle.node_id(),
7712 NodeKind::NonTerminal(handle.kind()),
7713 e,
7714 tree,
7715 ),
7716 };
7717 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7718 result
7719 }
7720 fn visit_lit_str_1_start_handle(
7721 &mut self,
7722 handle: LitStr1StartHandle,
7723 tree: &F,
7724 ) -> Result<(), V::Error> {
7725 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7726 Ok(nt_data) => nt_data,
7727 Err(error) => {
7728 return self.then_construct_error(
7729 None,
7730 handle.node_id(),
7731 NodeKind::NonTerminal(handle.kind()),
7732 error,
7733 tree,
7734 );
7735 }
7736 };
7737 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7738 let result = match handle
7739 .get_view_with_visit(
7740 tree,
7741 |view, visit: &mut Self| (visit.visit_lit_str_1_start(handle, view, tree), visit),
7742 self,
7743 )
7744 .map_err(|e| e.extract_error())
7745 {
7746 Ok(Ok(())) => Ok(()),
7747 Ok(Err(e)) => Err(e),
7748 Err(Ok(e)) => Err(e),
7749 Err(Err(e)) => self.then_construct_error(
7750 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7751 handle.node_id(),
7752 NodeKind::NonTerminal(handle.kind()),
7753 e,
7754 tree,
7755 ),
7756 };
7757 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7758 result
7759 }
7760 fn visit_lit_str_2_handle(&mut self, handle: LitStr2Handle, tree: &F) -> Result<(), V::Error> {
7761 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7762 Ok(nt_data) => nt_data,
7763 Err(error) => {
7764 return self.then_construct_error(
7765 None,
7766 handle.node_id(),
7767 NodeKind::NonTerminal(handle.kind()),
7768 error,
7769 tree,
7770 );
7771 }
7772 };
7773 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7774 let result = match handle
7775 .get_view_with_visit(
7776 tree,
7777 |view, visit: &mut Self| (visit.visit_lit_str_2(handle, view, tree), visit),
7778 self,
7779 )
7780 .map_err(|e| e.extract_error())
7781 {
7782 Ok(Ok(())) => Ok(()),
7783 Ok(Err(e)) => Err(e),
7784 Err(Ok(e)) => Err(e),
7785 Err(Err(e)) => self.then_construct_error(
7786 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7787 handle.node_id(),
7788 NodeKind::NonTerminal(handle.kind()),
7789 e,
7790 tree,
7791 ),
7792 };
7793 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7794 result
7795 }
7796 fn visit_lit_str_2_end_handle(
7797 &mut self,
7798 handle: LitStr2EndHandle,
7799 tree: &F,
7800 ) -> Result<(), V::Error> {
7801 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7802 Ok(nt_data) => nt_data,
7803 Err(error) => {
7804 return self.then_construct_error(
7805 None,
7806 handle.node_id(),
7807 NodeKind::NonTerminal(handle.kind()),
7808 error,
7809 tree,
7810 );
7811 }
7812 };
7813 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7814 let result = match handle
7815 .get_view_with_visit(
7816 tree,
7817 |view, visit: &mut Self| (visit.visit_lit_str_2_end(handle, view, tree), visit),
7818 self,
7819 )
7820 .map_err(|e| e.extract_error())
7821 {
7822 Ok(Ok(())) => Ok(()),
7823 Ok(Err(e)) => Err(e),
7824 Err(Ok(e)) => Err(e),
7825 Err(Err(e)) => self.then_construct_error(
7826 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7827 handle.node_id(),
7828 NodeKind::NonTerminal(handle.kind()),
7829 e,
7830 tree,
7831 ),
7832 };
7833 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7834 result
7835 }
7836 fn visit_lit_str_2_list_handle(
7837 &mut self,
7838 handle: LitStr2ListHandle,
7839 tree: &F,
7840 ) -> Result<(), V::Error> {
7841 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7842 Ok(nt_data) => nt_data,
7843 Err(error) => {
7844 return self.then_construct_error(
7845 None,
7846 handle.node_id(),
7847 NodeKind::NonTerminal(handle.kind()),
7848 error,
7849 tree,
7850 );
7851 }
7852 };
7853 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7854 let result = match handle
7855 .get_view_with_visit(
7856 tree,
7857 |view, visit: &mut Self| {
7858 (
7859 if let Some(view) = view {
7860 visit.visit_lit_str_2_list(handle, view, tree)
7861 } else {
7862 Ok(())
7863 },
7864 visit,
7865 )
7866 },
7867 self,
7868 )
7869 .map_err(|e| e.extract_error())
7870 {
7871 Ok(Ok(())) => Ok(()),
7872 Ok(Err(e)) => Err(e),
7873 Err(Ok(e)) => Err(e),
7874 Err(Err(e)) => self.then_construct_error(
7875 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7876 handle.node_id(),
7877 NodeKind::NonTerminal(handle.kind()),
7878 e,
7879 tree,
7880 ),
7881 };
7882 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7883 result
7884 }
7885 fn visit_lit_str_2_list_group_handle(
7886 &mut self,
7887 handle: LitStr2ListGroupHandle,
7888 tree: &F,
7889 ) -> Result<(), V::Error> {
7890 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7891 Ok(nt_data) => nt_data,
7892 Err(error) => {
7893 return self.then_construct_error(
7894 None,
7895 handle.node_id(),
7896 NodeKind::NonTerminal(handle.kind()),
7897 error,
7898 tree,
7899 );
7900 }
7901 };
7902 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7903 let result = match handle
7904 .get_view_with_visit(
7905 tree,
7906 |view, visit: &mut Self| {
7907 (visit.visit_lit_str_2_list_group(handle, view, tree), visit)
7908 },
7909 self,
7910 )
7911 .map_err(|e| e.extract_error())
7912 {
7913 Ok(Ok(())) => Ok(()),
7914 Ok(Err(e)) => Err(e),
7915 Err(Ok(e)) => Err(e),
7916 Err(Err(e)) => self.then_construct_error(
7917 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7918 handle.node_id(),
7919 NodeKind::NonTerminal(handle.kind()),
7920 e,
7921 tree,
7922 ),
7923 };
7924 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7925 result
7926 }
7927 fn visit_lit_str_2_start_handle(
7928 &mut self,
7929 handle: LitStr2StartHandle,
7930 tree: &F,
7931 ) -> Result<(), V::Error> {
7932 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7933 Ok(nt_data) => nt_data,
7934 Err(error) => {
7935 return self.then_construct_error(
7936 None,
7937 handle.node_id(),
7938 NodeKind::NonTerminal(handle.kind()),
7939 error,
7940 tree,
7941 );
7942 }
7943 };
7944 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7945 let result = match handle
7946 .get_view_with_visit(
7947 tree,
7948 |view, visit: &mut Self| (visit.visit_lit_str_2_start(handle, view, tree), visit),
7949 self,
7950 )
7951 .map_err(|e| e.extract_error())
7952 {
7953 Ok(Ok(())) => Ok(()),
7954 Ok(Err(e)) => Err(e),
7955 Err(Ok(e)) => Err(e),
7956 Err(Err(e)) => self.then_construct_error(
7957 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7958 handle.node_id(),
7959 NodeKind::NonTerminal(handle.kind()),
7960 e,
7961 tree,
7962 ),
7963 };
7964 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
7965 result
7966 }
7967 fn visit_lit_str_3_handle(&mut self, handle: LitStr3Handle, tree: &F) -> Result<(), V::Error> {
7968 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
7969 Ok(nt_data) => nt_data,
7970 Err(error) => {
7971 return self.then_construct_error(
7972 None,
7973 handle.node_id(),
7974 NodeKind::NonTerminal(handle.kind()),
7975 error,
7976 tree,
7977 );
7978 }
7979 };
7980 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
7981 let result = match handle
7982 .get_view_with_visit(
7983 tree,
7984 |view, visit: &mut Self| (visit.visit_lit_str_3(handle, view, tree), visit),
7985 self,
7986 )
7987 .map_err(|e| e.extract_error())
7988 {
7989 Ok(Ok(())) => Ok(()),
7990 Ok(Err(e)) => Err(e),
7991 Err(Ok(e)) => Err(e),
7992 Err(Err(e)) => self.then_construct_error(
7993 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
7994 handle.node_id(),
7995 NodeKind::NonTerminal(handle.kind()),
7996 e,
7997 tree,
7998 ),
7999 };
8000 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8001 result
8002 }
8003 fn visit_lit_str_3_end_handle(
8004 &mut self,
8005 handle: LitStr3EndHandle,
8006 tree: &F,
8007 ) -> Result<(), V::Error> {
8008 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8009 Ok(nt_data) => nt_data,
8010 Err(error) => {
8011 return self.then_construct_error(
8012 None,
8013 handle.node_id(),
8014 NodeKind::NonTerminal(handle.kind()),
8015 error,
8016 tree,
8017 );
8018 }
8019 };
8020 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8021 let result = match handle
8022 .get_view_with_visit(
8023 tree,
8024 |view, visit: &mut Self| (visit.visit_lit_str_3_end(handle, view, tree), visit),
8025 self,
8026 )
8027 .map_err(|e| e.extract_error())
8028 {
8029 Ok(Ok(())) => Ok(()),
8030 Ok(Err(e)) => Err(e),
8031 Err(Ok(e)) => Err(e),
8032 Err(Err(e)) => self.then_construct_error(
8033 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8034 handle.node_id(),
8035 NodeKind::NonTerminal(handle.kind()),
8036 e,
8037 tree,
8038 ),
8039 };
8040 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8041 result
8042 }
8043 fn visit_lit_str_3_list_handle(
8044 &mut self,
8045 handle: LitStr3ListHandle,
8046 tree: &F,
8047 ) -> Result<(), V::Error> {
8048 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8049 Ok(nt_data) => nt_data,
8050 Err(error) => {
8051 return self.then_construct_error(
8052 None,
8053 handle.node_id(),
8054 NodeKind::NonTerminal(handle.kind()),
8055 error,
8056 tree,
8057 );
8058 }
8059 };
8060 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8061 let result = match handle
8062 .get_view_with_visit(
8063 tree,
8064 |view, visit: &mut Self| {
8065 (
8066 if let Some(view) = view {
8067 visit.visit_lit_str_3_list(handle, view, tree)
8068 } else {
8069 Ok(())
8070 },
8071 visit,
8072 )
8073 },
8074 self,
8075 )
8076 .map_err(|e| e.extract_error())
8077 {
8078 Ok(Ok(())) => Ok(()),
8079 Ok(Err(e)) => Err(e),
8080 Err(Ok(e)) => Err(e),
8081 Err(Err(e)) => self.then_construct_error(
8082 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8083 handle.node_id(),
8084 NodeKind::NonTerminal(handle.kind()),
8085 e,
8086 tree,
8087 ),
8088 };
8089 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8090 result
8091 }
8092 fn visit_lit_str_3_list_group_handle(
8093 &mut self,
8094 handle: LitStr3ListGroupHandle,
8095 tree: &F,
8096 ) -> Result<(), V::Error> {
8097 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8098 Ok(nt_data) => nt_data,
8099 Err(error) => {
8100 return self.then_construct_error(
8101 None,
8102 handle.node_id(),
8103 NodeKind::NonTerminal(handle.kind()),
8104 error,
8105 tree,
8106 );
8107 }
8108 };
8109 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8110 let result = match handle
8111 .get_view_with_visit(
8112 tree,
8113 |view, visit: &mut Self| {
8114 (visit.visit_lit_str_3_list_group(handle, view, tree), visit)
8115 },
8116 self,
8117 )
8118 .map_err(|e| e.extract_error())
8119 {
8120 Ok(Ok(())) => Ok(()),
8121 Ok(Err(e)) => Err(e),
8122 Err(Ok(e)) => Err(e),
8123 Err(Err(e)) => self.then_construct_error(
8124 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8125 handle.node_id(),
8126 NodeKind::NonTerminal(handle.kind()),
8127 e,
8128 tree,
8129 ),
8130 };
8131 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8132 result
8133 }
8134 fn visit_lit_str_3_start_handle(
8135 &mut self,
8136 handle: LitStr3StartHandle,
8137 tree: &F,
8138 ) -> Result<(), V::Error> {
8139 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8140 Ok(nt_data) => nt_data,
8141 Err(error) => {
8142 return self.then_construct_error(
8143 None,
8144 handle.node_id(),
8145 NodeKind::NonTerminal(handle.kind()),
8146 error,
8147 tree,
8148 );
8149 }
8150 };
8151 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8152 let result = match handle
8153 .get_view_with_visit(
8154 tree,
8155 |view, visit: &mut Self| (visit.visit_lit_str_3_start(handle, view, tree), visit),
8156 self,
8157 )
8158 .map_err(|e| e.extract_error())
8159 {
8160 Ok(Ok(())) => Ok(()),
8161 Ok(Err(e)) => Err(e),
8162 Err(Ok(e)) => Err(e),
8163 Err(Err(e)) => self.then_construct_error(
8164 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8165 handle.node_id(),
8166 NodeKind::NonTerminal(handle.kind()),
8167 e,
8168 tree,
8169 ),
8170 };
8171 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8172 result
8173 }
8174 fn visit_map_bind_handle(&mut self, handle: MapBindHandle, tree: &F) -> Result<(), V::Error> {
8175 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8176 Ok(nt_data) => nt_data,
8177 Err(error) => {
8178 return self.then_construct_error(
8179 None,
8180 handle.node_id(),
8181 NodeKind::NonTerminal(handle.kind()),
8182 error,
8183 tree,
8184 );
8185 }
8186 };
8187 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8188 let result = match handle
8189 .get_view_with_visit(
8190 tree,
8191 |view, visit: &mut Self| (visit.visit_map_bind(handle, view, tree), visit),
8192 self,
8193 )
8194 .map_err(|e| e.extract_error())
8195 {
8196 Ok(Ok(())) => Ok(()),
8197 Ok(Err(e)) => Err(e),
8198 Err(Ok(e)) => Err(e),
8199 Err(Err(e)) => self.then_construct_error(
8200 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8201 handle.node_id(),
8202 NodeKind::NonTerminal(handle.kind()),
8203 e,
8204 tree,
8205 ),
8206 };
8207 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8208 result
8209 }
8210 fn visit_na_n_handle(&mut self, handle: NaNHandle, tree: &F) -> Result<(), V::Error> {
8211 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8212 Ok(nt_data) => nt_data,
8213 Err(error) => {
8214 return self.then_construct_error(
8215 None,
8216 handle.node_id(),
8217 NodeKind::NonTerminal(handle.kind()),
8218 error,
8219 tree,
8220 );
8221 }
8222 };
8223 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8224 let result = match handle
8225 .get_view_with_visit(
8226 tree,
8227 |view, visit: &mut Self| (visit.visit_na_n(handle, view, tree), visit),
8228 self,
8229 )
8230 .map_err(|e| e.extract_error())
8231 {
8232 Ok(Ok(())) => Ok(()),
8233 Ok(Err(e)) => Err(e),
8234 Err(Ok(e)) => Err(e),
8235 Err(Err(e)) => self.then_construct_error(
8236 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8237 handle.node_id(),
8238 NodeKind::NonTerminal(handle.kind()),
8239 e,
8240 tree,
8241 ),
8242 };
8243 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8244 result
8245 }
8246 fn visit_newline_bind_handle(
8247 &mut self,
8248 handle: NewlineBindHandle,
8249 tree: &F,
8250 ) -> Result<(), V::Error> {
8251 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8252 Ok(nt_data) => nt_data,
8253 Err(error) => {
8254 return self.then_construct_error(
8255 None,
8256 handle.node_id(),
8257 NodeKind::NonTerminal(handle.kind()),
8258 error,
8259 tree,
8260 );
8261 }
8262 };
8263 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8264 let result = match handle
8265 .get_view_with_visit(
8266 tree,
8267 |view, visit: &mut Self| (visit.visit_newline_bind(handle, view, tree), visit),
8268 self,
8269 )
8270 .map_err(|e| e.extract_error())
8271 {
8272 Ok(Ok(())) => Ok(()),
8273 Ok(Err(e)) => Err(e),
8274 Err(Ok(e)) => Err(e),
8275 Err(Err(e)) => self.then_construct_error(
8276 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8277 handle.node_id(),
8278 NodeKind::NonTerminal(handle.kind()),
8279 e,
8280 tree,
8281 ),
8282 };
8283 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8284 result
8285 }
8286 fn visit_newline_head_handle(
8287 &mut self,
8288 handle: NewlineHeadHandle,
8289 tree: &F,
8290 ) -> Result<(), V::Error> {
8291 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8292 Ok(nt_data) => nt_data,
8293 Err(error) => {
8294 return self.then_construct_error(
8295 None,
8296 handle.node_id(),
8297 NodeKind::NonTerminal(handle.kind()),
8298 error,
8299 tree,
8300 );
8301 }
8302 };
8303 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8304 let result = match handle
8305 .get_view_with_visit(
8306 tree,
8307 |view, visit: &mut Self| (visit.visit_newline_head(handle, view, tree), visit),
8308 self,
8309 )
8310 .map_err(|e| e.extract_error())
8311 {
8312 Ok(Ok(())) => Ok(()),
8313 Ok(Err(e)) => Err(e),
8314 Err(Ok(e)) => Err(e),
8315 Err(Err(e)) => self.then_construct_error(
8316 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8317 handle.node_id(),
8318 NodeKind::NonTerminal(handle.kind()),
8319 e,
8320 tree,
8321 ),
8322 };
8323 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8324 result
8325 }
8326 fn visit_newline_head_opt_handle(
8327 &mut self,
8328 handle: NewlineHeadOptHandle,
8329 tree: &F,
8330 ) -> Result<(), V::Error> {
8331 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8332 Ok(nt_data) => nt_data,
8333 Err(error) => {
8334 return self.then_construct_error(
8335 None,
8336 handle.node_id(),
8337 NodeKind::NonTerminal(handle.kind()),
8338 error,
8339 tree,
8340 );
8341 }
8342 };
8343 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8344 let result = match handle
8345 .get_view_with_visit(
8346 tree,
8347 |view, visit: &mut Self| {
8348 (
8349 if let Some(view) = view {
8350 visit.visit_newline_head_opt(handle, view, tree)
8351 } else {
8352 Ok(())
8353 },
8354 visit,
8355 )
8356 },
8357 self,
8358 )
8359 .map_err(|e| e.extract_error())
8360 {
8361 Ok(Ok(())) => Ok(()),
8362 Ok(Err(e)) => Err(e),
8363 Err(Ok(e)) => Err(e),
8364 Err(Err(e)) => self.then_construct_error(
8365 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8366 handle.node_id(),
8367 NodeKind::NonTerminal(handle.kind()),
8368 e,
8369 tree,
8370 ),
8371 };
8372 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8373 result
8374 }
8375 fn visit_newline_text_start_handle(
8376 &mut self,
8377 handle: NewlineTextStartHandle,
8378 tree: &F,
8379 ) -> Result<(), V::Error> {
8380 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8381 Ok(nt_data) => nt_data,
8382 Err(error) => {
8383 return self.then_construct_error(
8384 None,
8385 handle.node_id(),
8386 NodeKind::NonTerminal(handle.kind()),
8387 error,
8388 tree,
8389 );
8390 }
8391 };
8392 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8393 let result = match handle
8394 .get_view_with_visit(
8395 tree,
8396 |view, visit: &mut Self| {
8397 (visit.visit_newline_text_start(handle, view, tree), visit)
8398 },
8399 self,
8400 )
8401 .map_err(|e| e.extract_error())
8402 {
8403 Ok(Ok(())) => Ok(()),
8404 Ok(Err(e)) => Err(e),
8405 Err(Ok(e)) => Err(e),
8406 Err(Err(e)) => self.then_construct_error(
8407 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8408 handle.node_id(),
8409 NodeKind::NonTerminal(handle.kind()),
8410 e,
8411 tree,
8412 ),
8413 };
8414 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8415 result
8416 }
8417 fn visit_no_backtick_handle(
8418 &mut self,
8419 handle: NoBacktickHandle,
8420 tree: &F,
8421 ) -> Result<(), V::Error> {
8422 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8423 Ok(nt_data) => nt_data,
8424 Err(error) => {
8425 return self.then_construct_error(
8426 None,
8427 handle.node_id(),
8428 NodeKind::NonTerminal(handle.kind()),
8429 error,
8430 tree,
8431 );
8432 }
8433 };
8434 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8435 let result = match handle
8436 .get_view_with_visit(
8437 tree,
8438 |view, visit: &mut Self| (visit.visit_no_backtick(handle, view, tree), visit),
8439 self,
8440 )
8441 .map_err(|e| e.extract_error())
8442 {
8443 Ok(Ok(())) => Ok(()),
8444 Ok(Err(e)) => Err(e),
8445 Err(Ok(e)) => Err(e),
8446 Err(Err(e)) => self.then_construct_error(
8447 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8448 handle.node_id(),
8449 NodeKind::NonTerminal(handle.kind()),
8450 e,
8451 tree,
8452 ),
8453 };
8454 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8455 result
8456 }
8457 fn visit_no_s_quote_handle(
8458 &mut self,
8459 handle: NoSQuoteHandle,
8460 tree: &F,
8461 ) -> Result<(), V::Error> {
8462 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8463 Ok(nt_data) => nt_data,
8464 Err(error) => {
8465 return self.then_construct_error(
8466 None,
8467 handle.node_id(),
8468 NodeKind::NonTerminal(handle.kind()),
8469 error,
8470 tree,
8471 );
8472 }
8473 };
8474 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8475 let result = match handle
8476 .get_view_with_visit(
8477 tree,
8478 |view, visit: &mut Self| (visit.visit_no_s_quote(handle, view, tree), visit),
8479 self,
8480 )
8481 .map_err(|e| e.extract_error())
8482 {
8483 Ok(Ok(())) => Ok(()),
8484 Ok(Err(e)) => Err(e),
8485 Err(Ok(e)) => Err(e),
8486 Err(Err(e)) => self.then_construct_error(
8487 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8488 handle.node_id(),
8489 NodeKind::NonTerminal(handle.kind()),
8490 e,
8491 tree,
8492 ),
8493 };
8494 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8495 result
8496 }
8497 fn visit_null_handle(&mut self, handle: NullHandle, tree: &F) -> Result<(), V::Error> {
8498 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8499 Ok(nt_data) => nt_data,
8500 Err(error) => {
8501 return self.then_construct_error(
8502 None,
8503 handle.node_id(),
8504 NodeKind::NonTerminal(handle.kind()),
8505 error,
8506 tree,
8507 );
8508 }
8509 };
8510 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8511 let result = match handle
8512 .get_view_with_visit(
8513 tree,
8514 |view, visit: &mut Self| (visit.visit_null(handle, view, tree), visit),
8515 self,
8516 )
8517 .map_err(|e| e.extract_error())
8518 {
8519 Ok(Ok(())) => Ok(()),
8520 Ok(Err(e)) => Err(e),
8521 Err(Ok(e)) => Err(e),
8522 Err(Err(e)) => self.then_construct_error(
8523 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8524 handle.node_id(),
8525 NodeKind::NonTerminal(handle.kind()),
8526 e,
8527 tree,
8528 ),
8529 };
8530 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8531 result
8532 }
8533 fn visit_number_handle(&mut self, handle: NumberHandle, tree: &F) -> Result<(), V::Error> {
8534 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8535 Ok(nt_data) => nt_data,
8536 Err(error) => {
8537 return self.then_construct_error(
8538 None,
8539 handle.node_id(),
8540 NodeKind::NonTerminal(handle.kind()),
8541 error,
8542 tree,
8543 );
8544 }
8545 };
8546 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8547 let result = match handle
8548 .get_view_with_visit(
8549 tree,
8550 |view, visit: &mut Self| (visit.visit_number(handle, view, tree), visit),
8551 self,
8552 )
8553 .map_err(|e| e.extract_error())
8554 {
8555 Ok(Ok(())) => Ok(()),
8556 Ok(Err(e)) => Err(e),
8557 Err(Ok(e)) => Err(e),
8558 Err(Err(e)) => self.then_construct_error(
8559 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8560 handle.node_id(),
8561 NodeKind::NonTerminal(handle.kind()),
8562 e,
8563 tree,
8564 ),
8565 };
8566 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8567 result
8568 }
8569 fn visit_object_handle(&mut self, handle: ObjectHandle, tree: &F) -> Result<(), V::Error> {
8570 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8571 Ok(nt_data) => nt_data,
8572 Err(error) => {
8573 return self.then_construct_error(
8574 None,
8575 handle.node_id(),
8576 NodeKind::NonTerminal(handle.kind()),
8577 error,
8578 tree,
8579 );
8580 }
8581 };
8582 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8583 let result = match handle
8584 .get_view_with_visit(
8585 tree,
8586 |view, visit: &mut Self| (visit.visit_object(handle, view, tree), visit),
8587 self,
8588 )
8589 .map_err(|e| e.extract_error())
8590 {
8591 Ok(Ok(())) => Ok(()),
8592 Ok(Err(e)) => Err(e),
8593 Err(Ok(e)) => Err(e),
8594 Err(Err(e)) => self.then_construct_error(
8595 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8596 handle.node_id(),
8597 NodeKind::NonTerminal(handle.kind()),
8598 e,
8599 tree,
8600 ),
8601 };
8602 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8603 result
8604 }
8605 fn visit_object_list_handle(
8606 &mut self,
8607 handle: ObjectListHandle,
8608 tree: &F,
8609 ) -> Result<(), V::Error> {
8610 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8611 Ok(nt_data) => nt_data,
8612 Err(error) => {
8613 return self.then_construct_error(
8614 None,
8615 handle.node_id(),
8616 NodeKind::NonTerminal(handle.kind()),
8617 error,
8618 tree,
8619 );
8620 }
8621 };
8622 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8623 let result = match handle
8624 .get_view_with_visit(
8625 tree,
8626 |view, visit: &mut Self| {
8627 (
8628 if let Some(view) = view {
8629 visit.visit_object_list(handle, view, tree)
8630 } else {
8631 Ok(())
8632 },
8633 visit,
8634 )
8635 },
8636 self,
8637 )
8638 .map_err(|e| e.extract_error())
8639 {
8640 Ok(Ok(())) => Ok(()),
8641 Ok(Err(e)) => Err(e),
8642 Err(Ok(e)) => Err(e),
8643 Err(Err(e)) => self.then_construct_error(
8644 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8645 handle.node_id(),
8646 NodeKind::NonTerminal(handle.kind()),
8647 e,
8648 tree,
8649 ),
8650 };
8651 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8652 result
8653 }
8654 fn visit_object_opt_handle(
8655 &mut self,
8656 handle: ObjectOptHandle,
8657 tree: &F,
8658 ) -> Result<(), V::Error> {
8659 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8660 Ok(nt_data) => nt_data,
8661 Err(error) => {
8662 return self.then_construct_error(
8663 None,
8664 handle.node_id(),
8665 NodeKind::NonTerminal(handle.kind()),
8666 error,
8667 tree,
8668 );
8669 }
8670 };
8671 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8672 let result = match handle
8673 .get_view_with_visit(
8674 tree,
8675 |view, visit: &mut Self| {
8676 (
8677 if let Some(view) = view {
8678 visit.visit_object_opt(handle, view, tree)
8679 } else {
8680 Ok(())
8681 },
8682 visit,
8683 )
8684 },
8685 self,
8686 )
8687 .map_err(|e| e.extract_error())
8688 {
8689 Ok(Ok(())) => Ok(()),
8690 Ok(Err(e)) => Err(e),
8691 Err(Ok(e)) => Err(e),
8692 Err(Err(e)) => self.then_construct_error(
8693 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8694 handle.node_id(),
8695 NodeKind::NonTerminal(handle.kind()),
8696 e,
8697 tree,
8698 ),
8699 };
8700 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8701 result
8702 }
8703 fn visit_object_opt_0_handle(
8704 &mut self,
8705 handle: ObjectOpt0Handle,
8706 tree: &F,
8707 ) -> Result<(), V::Error> {
8708 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8709 Ok(nt_data) => nt_data,
8710 Err(error) => {
8711 return self.then_construct_error(
8712 None,
8713 handle.node_id(),
8714 NodeKind::NonTerminal(handle.kind()),
8715 error,
8716 tree,
8717 );
8718 }
8719 };
8720 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8721 let result = match handle
8722 .get_view_with_visit(
8723 tree,
8724 |view, visit: &mut Self| {
8725 (
8726 if let Some(view) = view {
8727 visit.visit_object_opt_0(handle, view, tree)
8728 } else {
8729 Ok(())
8730 },
8731 visit,
8732 )
8733 },
8734 self,
8735 )
8736 .map_err(|e| e.extract_error())
8737 {
8738 Ok(Ok(())) => Ok(()),
8739 Ok(Err(e)) => Err(e),
8740 Err(Ok(e)) => Err(e),
8741 Err(Err(e)) => self.then_construct_error(
8742 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8743 handle.node_id(),
8744 NodeKind::NonTerminal(handle.kind()),
8745 e,
8746 tree,
8747 ),
8748 };
8749 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8750 result
8751 }
8752 fn visit_object_opt_1_handle(
8753 &mut self,
8754 handle: ObjectOpt1Handle,
8755 tree: &F,
8756 ) -> Result<(), V::Error> {
8757 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8758 Ok(nt_data) => nt_data,
8759 Err(error) => {
8760 return self.then_construct_error(
8761 None,
8762 handle.node_id(),
8763 NodeKind::NonTerminal(handle.kind()),
8764 error,
8765 tree,
8766 );
8767 }
8768 };
8769 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8770 let result = match handle
8771 .get_view_with_visit(
8772 tree,
8773 |view, visit: &mut Self| {
8774 (
8775 if let Some(view) = view {
8776 visit.visit_object_opt_1(handle, view, tree)
8777 } else {
8778 Ok(())
8779 },
8780 visit,
8781 )
8782 },
8783 self,
8784 )
8785 .map_err(|e| e.extract_error())
8786 {
8787 Ok(Ok(())) => Ok(()),
8788 Ok(Err(e)) => Err(e),
8789 Err(Ok(e)) => Err(e),
8790 Err(Err(e)) => self.then_construct_error(
8791 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8792 handle.node_id(),
8793 NodeKind::NonTerminal(handle.kind()),
8794 e,
8795 tree,
8796 ),
8797 };
8798 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8799 result
8800 }
8801 fn visit_r_paren_handle(&mut self, handle: RParenHandle, tree: &F) -> Result<(), V::Error> {
8802 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8803 Ok(nt_data) => nt_data,
8804 Err(error) => {
8805 return self.then_construct_error(
8806 None,
8807 handle.node_id(),
8808 NodeKind::NonTerminal(handle.kind()),
8809 error,
8810 tree,
8811 );
8812 }
8813 };
8814 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8815 let result = match handle
8816 .get_view_with_visit(
8817 tree,
8818 |view, visit: &mut Self| (visit.visit_r_paren(handle, view, tree), visit),
8819 self,
8820 )
8821 .map_err(|e| e.extract_error())
8822 {
8823 Ok(Ok(())) => Ok(()),
8824 Ok(Err(e)) => Err(e),
8825 Err(Ok(e)) => Err(e),
8826 Err(Err(e)) => self.then_construct_error(
8827 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8828 handle.node_id(),
8829 NodeKind::NonTerminal(handle.kind()),
8830 e,
8831 tree,
8832 ),
8833 };
8834 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8835 result
8836 }
8837 fn visit_root_binding_handle(
8838 &mut self,
8839 handle: RootBindingHandle,
8840 tree: &F,
8841 ) -> Result<(), V::Error> {
8842 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8843 Ok(nt_data) => nt_data,
8844 Err(error) => {
8845 return self.then_construct_error(
8846 None,
8847 handle.node_id(),
8848 NodeKind::NonTerminal(handle.kind()),
8849 error,
8850 tree,
8851 );
8852 }
8853 };
8854 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8855 let result = match handle
8856 .get_view_with_visit(
8857 tree,
8858 |view, visit: &mut Self| (visit.visit_root_binding(handle, view, tree), visit),
8859 self,
8860 )
8861 .map_err(|e| e.extract_error())
8862 {
8863 Ok(Ok(())) => Ok(()),
8864 Ok(Err(e)) => Err(e),
8865 Err(Ok(e)) => Err(e),
8866 Err(Err(e)) => self.then_construct_error(
8867 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8868 handle.node_id(),
8869 NodeKind::NonTerminal(handle.kind()),
8870 e,
8871 tree,
8872 ),
8873 };
8874 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8875 result
8876 }
8877 fn visit_root_text_binding_handle(
8878 &mut self,
8879 handle: RootTextBindingHandle,
8880 tree: &F,
8881 ) -> Result<(), V::Error> {
8882 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8883 Ok(nt_data) => nt_data,
8884 Err(error) => {
8885 return self.then_construct_error(
8886 None,
8887 handle.node_id(),
8888 NodeKind::NonTerminal(handle.kind()),
8889 error,
8890 tree,
8891 );
8892 }
8893 };
8894 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8895 let result = match handle
8896 .get_view_with_visit(
8897 tree,
8898 |view, visit: &mut Self| (visit.visit_root_text_binding(handle, view, tree), visit),
8899 self,
8900 )
8901 .map_err(|e| e.extract_error())
8902 {
8903 Ok(Ok(())) => Ok(()),
8904 Ok(Err(e)) => Err(e),
8905 Err(Ok(e)) => Err(e),
8906 Err(Err(e)) => self.then_construct_error(
8907 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8908 handle.node_id(),
8909 NodeKind::NonTerminal(handle.kind()),
8910 e,
8911 tree,
8912 ),
8913 };
8914 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8915 result
8916 }
8917 fn visit_root_text_binding_opt_handle(
8918 &mut self,
8919 handle: RootTextBindingOptHandle,
8920 tree: &F,
8921 ) -> Result<(), V::Error> {
8922 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8923 Ok(nt_data) => nt_data,
8924 Err(error) => {
8925 return self.then_construct_error(
8926 None,
8927 handle.node_id(),
8928 NodeKind::NonTerminal(handle.kind()),
8929 error,
8930 tree,
8931 );
8932 }
8933 };
8934 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8935 let result = match handle
8936 .get_view_with_visit(
8937 tree,
8938 |view, visit: &mut Self| {
8939 (
8940 if let Some(view) = view {
8941 visit.visit_root_text_binding_opt(handle, view, tree)
8942 } else {
8943 Ok(())
8944 },
8945 visit,
8946 )
8947 },
8948 self,
8949 )
8950 .map_err(|e| e.extract_error())
8951 {
8952 Ok(Ok(())) => Ok(()),
8953 Ok(Err(e)) => Err(e),
8954 Err(Ok(e)) => Err(e),
8955 Err(Err(e)) => self.then_construct_error(
8956 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
8957 handle.node_id(),
8958 NodeKind::NonTerminal(handle.kind()),
8959 e,
8960 tree,
8961 ),
8962 };
8963 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
8964 result
8965 }
8966 fn visit_root_text_binding_opt_0_handle(
8967 &mut self,
8968 handle: RootTextBindingOpt0Handle,
8969 tree: &F,
8970 ) -> Result<(), V::Error> {
8971 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
8972 Ok(nt_data) => nt_data,
8973 Err(error) => {
8974 return self.then_construct_error(
8975 None,
8976 handle.node_id(),
8977 NodeKind::NonTerminal(handle.kind()),
8978 error,
8979 tree,
8980 );
8981 }
8982 };
8983 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
8984 let result = match handle
8985 .get_view_with_visit(
8986 tree,
8987 |view, visit: &mut Self| {
8988 (
8989 if let Some(view) = view {
8990 visit.visit_root_text_binding_opt_0(handle, view, tree)
8991 } else {
8992 Ok(())
8993 },
8994 visit,
8995 )
8996 },
8997 self,
8998 )
8999 .map_err(|e| e.extract_error())
9000 {
9001 Ok(Ok(())) => Ok(()),
9002 Ok(Err(e)) => Err(e),
9003 Err(Ok(e)) => Err(e),
9004 Err(Err(e)) => self.then_construct_error(
9005 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9006 handle.node_id(),
9007 NodeKind::NonTerminal(handle.kind()),
9008 e,
9009 tree,
9010 ),
9011 };
9012 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9013 result
9014 }
9015 fn visit_root_text_binding_opt_1_handle(
9016 &mut self,
9017 handle: RootTextBindingOpt1Handle,
9018 tree: &F,
9019 ) -> Result<(), V::Error> {
9020 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9021 Ok(nt_data) => nt_data,
9022 Err(error) => {
9023 return self.then_construct_error(
9024 None,
9025 handle.node_id(),
9026 NodeKind::NonTerminal(handle.kind()),
9027 error,
9028 tree,
9029 );
9030 }
9031 };
9032 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9033 let result = match handle
9034 .get_view_with_visit(
9035 tree,
9036 |view, visit: &mut Self| {
9037 (
9038 if let Some(view) = view {
9039 visit.visit_root_text_binding_opt_1(handle, view, tree)
9040 } else {
9041 Ok(())
9042 },
9043 visit,
9044 )
9045 },
9046 self,
9047 )
9048 .map_err(|e| e.extract_error())
9049 {
9050 Ok(Ok(())) => Ok(()),
9051 Ok(Err(e)) => Err(e),
9052 Err(Ok(e)) => Err(e),
9053 Err(Err(e)) => self.then_construct_error(
9054 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9055 handle.node_id(),
9056 NodeKind::NonTerminal(handle.kind()),
9057 e,
9058 tree,
9059 ),
9060 };
9061 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9062 result
9063 }
9064 fn visit_root_value_binding_handle(
9065 &mut self,
9066 handle: RootValueBindingHandle,
9067 tree: &F,
9068 ) -> Result<(), V::Error> {
9069 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9070 Ok(nt_data) => nt_data,
9071 Err(error) => {
9072 return self.then_construct_error(
9073 None,
9074 handle.node_id(),
9075 NodeKind::NonTerminal(handle.kind()),
9076 error,
9077 tree,
9078 );
9079 }
9080 };
9081 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9082 let result = match handle
9083 .get_view_with_visit(
9084 tree,
9085 |view, visit: &mut Self| {
9086 (visit.visit_root_value_binding(handle, view, tree), visit)
9087 },
9088 self,
9089 )
9090 .map_err(|e| e.extract_error())
9091 {
9092 Ok(Ok(())) => Ok(()),
9093 Ok(Err(e)) => Err(e),
9094 Err(Ok(e)) => Err(e),
9095 Err(Err(e)) => self.then_construct_error(
9096 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9097 handle.node_id(),
9098 NodeKind::NonTerminal(handle.kind()),
9099 e,
9100 tree,
9101 ),
9102 };
9103 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9104 result
9105 }
9106 fn visit_s_quote_handle(&mut self, handle: SQuoteHandle, tree: &F) -> Result<(), V::Error> {
9107 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9108 Ok(nt_data) => nt_data,
9109 Err(error) => {
9110 return self.then_construct_error(
9111 None,
9112 handle.node_id(),
9113 NodeKind::NonTerminal(handle.kind()),
9114 error,
9115 tree,
9116 );
9117 }
9118 };
9119 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9120 let result = match handle
9121 .get_view_with_visit(
9122 tree,
9123 |view, visit: &mut Self| (visit.visit_s_quote(handle, view, tree), visit),
9124 self,
9125 )
9126 .map_err(|e| e.extract_error())
9127 {
9128 Ok(Ok(())) => Ok(()),
9129 Ok(Err(e)) => Err(e),
9130 Err(Ok(e)) => Err(e),
9131 Err(Err(e)) => self.then_construct_error(
9132 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9133 handle.node_id(),
9134 NodeKind::NonTerminal(handle.kind()),
9135 e,
9136 tree,
9137 ),
9138 };
9139 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9140 result
9141 }
9142 fn visit_section_handle(&mut self, handle: SectionHandle, tree: &F) -> Result<(), V::Error> {
9143 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9144 Ok(nt_data) => nt_data,
9145 Err(error) => {
9146 return self.then_construct_error(
9147 None,
9148 handle.node_id(),
9149 NodeKind::NonTerminal(handle.kind()),
9150 error,
9151 tree,
9152 );
9153 }
9154 };
9155 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9156 let result = match handle
9157 .get_view_with_visit(
9158 tree,
9159 |view, visit: &mut Self| (visit.visit_section(handle, view, tree), visit),
9160 self,
9161 )
9162 .map_err(|e| e.extract_error())
9163 {
9164 Ok(Ok(())) => Ok(()),
9165 Ok(Err(e)) => Err(e),
9166 Err(Ok(e)) => Err(e),
9167 Err(Err(e)) => self.then_construct_error(
9168 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9169 handle.node_id(),
9170 NodeKind::NonTerminal(handle.kind()),
9171 e,
9172 tree,
9173 ),
9174 };
9175 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9176 result
9177 }
9178 fn visit_section_binding_handle(
9179 &mut self,
9180 handle: SectionBindingHandle,
9181 tree: &F,
9182 ) -> Result<(), V::Error> {
9183 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9184 Ok(nt_data) => nt_data,
9185 Err(error) => {
9186 return self.then_construct_error(
9187 None,
9188 handle.node_id(),
9189 NodeKind::NonTerminal(handle.kind()),
9190 error,
9191 tree,
9192 );
9193 }
9194 };
9195 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9196 let result = match handle
9197 .get_view_with_visit(
9198 tree,
9199 |view, visit: &mut Self| (visit.visit_section_binding(handle, view, tree), visit),
9200 self,
9201 )
9202 .map_err(|e| e.extract_error())
9203 {
9204 Ok(Ok(())) => Ok(()),
9205 Ok(Err(e)) => Err(e),
9206 Err(Ok(e)) => Err(e),
9207 Err(Err(e)) => self.then_construct_error(
9208 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9209 handle.node_id(),
9210 NodeKind::NonTerminal(handle.kind()),
9211 e,
9212 tree,
9213 ),
9214 };
9215 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9216 result
9217 }
9218 fn visit_section_body_handle(
9219 &mut self,
9220 handle: SectionBodyHandle,
9221 tree: &F,
9222 ) -> Result<(), V::Error> {
9223 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9224 Ok(nt_data) => nt_data,
9225 Err(error) => {
9226 return self.then_construct_error(
9227 None,
9228 handle.node_id(),
9229 NodeKind::NonTerminal(handle.kind()),
9230 error,
9231 tree,
9232 );
9233 }
9234 };
9235 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9236 let result = match handle
9237 .get_view_with_visit(
9238 tree,
9239 |view, visit: &mut Self| (visit.visit_section_body(handle, view, tree), visit),
9240 self,
9241 )
9242 .map_err(|e| e.extract_error())
9243 {
9244 Ok(Ok(())) => Ok(()),
9245 Ok(Err(e)) => Err(e),
9246 Err(Ok(e)) => Err(e),
9247 Err(Err(e)) => self.then_construct_error(
9248 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9249 handle.node_id(),
9250 NodeKind::NonTerminal(handle.kind()),
9251 e,
9252 tree,
9253 ),
9254 };
9255 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9256 result
9257 }
9258 fn visit_section_body_opt_handle(
9259 &mut self,
9260 handle: SectionBodyOptHandle,
9261 tree: &F,
9262 ) -> Result<(), V::Error> {
9263 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9264 Ok(nt_data) => nt_data,
9265 Err(error) => {
9266 return self.then_construct_error(
9267 None,
9268 handle.node_id(),
9269 NodeKind::NonTerminal(handle.kind()),
9270 error,
9271 tree,
9272 );
9273 }
9274 };
9275 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9276 let result = match handle
9277 .get_view_with_visit(
9278 tree,
9279 |view, visit: &mut Self| {
9280 (
9281 if let Some(view) = view {
9282 visit.visit_section_body_opt(handle, view, tree)
9283 } else {
9284 Ok(())
9285 },
9286 visit,
9287 )
9288 },
9289 self,
9290 )
9291 .map_err(|e| e.extract_error())
9292 {
9293 Ok(Ok(())) => Ok(()),
9294 Ok(Err(e)) => Err(e),
9295 Err(Ok(e)) => Err(e),
9296 Err(Err(e)) => self.then_construct_error(
9297 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9298 handle.node_id(),
9299 NodeKind::NonTerminal(handle.kind()),
9300 e,
9301 tree,
9302 ),
9303 };
9304 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9305 result
9306 }
9307 fn visit_section_head_handle(
9308 &mut self,
9309 handle: SectionHeadHandle,
9310 tree: &F,
9311 ) -> Result<(), V::Error> {
9312 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9313 Ok(nt_data) => nt_data,
9314 Err(error) => {
9315 return self.then_construct_error(
9316 None,
9317 handle.node_id(),
9318 NodeKind::NonTerminal(handle.kind()),
9319 error,
9320 tree,
9321 );
9322 }
9323 };
9324 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9325 let result = match handle
9326 .get_view_with_visit(
9327 tree,
9328 |view, visit: &mut Self| (visit.visit_section_head(handle, view, tree), visit),
9329 self,
9330 )
9331 .map_err(|e| e.extract_error())
9332 {
9333 Ok(Ok(())) => Ok(()),
9334 Ok(Err(e)) => Err(e),
9335 Err(Ok(e)) => Err(e),
9336 Err(Err(e)) => self.then_construct_error(
9337 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9338 handle.node_id(),
9339 NodeKind::NonTerminal(handle.kind()),
9340 e,
9341 tree,
9342 ),
9343 };
9344 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9345 result
9346 }
9347 fn visit_str_handle(&mut self, handle: StrHandle, tree: &F) -> Result<(), V::Error> {
9348 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9349 Ok(nt_data) => nt_data,
9350 Err(error) => {
9351 return self.then_construct_error(
9352 None,
9353 handle.node_id(),
9354 NodeKind::NonTerminal(handle.kind()),
9355 error,
9356 tree,
9357 );
9358 }
9359 };
9360 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9361 let result = match handle
9362 .get_view_with_visit(
9363 tree,
9364 |view, visit: &mut Self| (visit.visit_str(handle, view, tree), visit),
9365 self,
9366 )
9367 .map_err(|e| e.extract_error())
9368 {
9369 Ok(Ok(())) => Ok(()),
9370 Ok(Err(e)) => Err(e),
9371 Err(Ok(e)) => Err(e),
9372 Err(Err(e)) => self.then_construct_error(
9373 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9374 handle.node_id(),
9375 NodeKind::NonTerminal(handle.kind()),
9376 e,
9377 tree,
9378 ),
9379 };
9380 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9381 result
9382 }
9383 fn visit_string_handle(&mut self, handle: StringHandle, tree: &F) -> Result<(), V::Error> {
9384 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9385 Ok(nt_data) => nt_data,
9386 Err(error) => {
9387 return self.then_construct_error(
9388 None,
9389 handle.node_id(),
9390 NodeKind::NonTerminal(handle.kind()),
9391 error,
9392 tree,
9393 );
9394 }
9395 };
9396 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9397 let result = match handle
9398 .get_view_with_visit(
9399 tree,
9400 |view, visit: &mut Self| (visit.visit_string(handle, view, tree), visit),
9401 self,
9402 )
9403 .map_err(|e| e.extract_error())
9404 {
9405 Ok(Ok(())) => Ok(()),
9406 Ok(Err(e)) => Err(e),
9407 Err(Ok(e)) => Err(e),
9408 Err(Err(e)) => self.then_construct_error(
9409 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9410 handle.node_id(),
9411 NodeKind::NonTerminal(handle.kind()),
9412 e,
9413 tree,
9414 ),
9415 };
9416 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9417 result
9418 }
9419 fn visit_strings_handle(&mut self, handle: StringsHandle, tree: &F) -> Result<(), V::Error> {
9420 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9421 Ok(nt_data) => nt_data,
9422 Err(error) => {
9423 return self.then_construct_error(
9424 None,
9425 handle.node_id(),
9426 NodeKind::NonTerminal(handle.kind()),
9427 error,
9428 tree,
9429 );
9430 }
9431 };
9432 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9433 let result = match handle
9434 .get_view_with_visit(
9435 tree,
9436 |view, visit: &mut Self| (visit.visit_strings(handle, view, tree), visit),
9437 self,
9438 )
9439 .map_err(|e| e.extract_error())
9440 {
9441 Ok(Ok(())) => Ok(()),
9442 Ok(Err(e)) => Err(e),
9443 Err(Ok(e)) => Err(e),
9444 Err(Err(e)) => self.then_construct_error(
9445 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9446 handle.node_id(),
9447 NodeKind::NonTerminal(handle.kind()),
9448 e,
9449 tree,
9450 ),
9451 };
9452 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9453 result
9454 }
9455 fn visit_strings_list_handle(
9456 &mut self,
9457 handle: StringsListHandle,
9458 tree: &F,
9459 ) -> Result<(), V::Error> {
9460 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9461 Ok(nt_data) => nt_data,
9462 Err(error) => {
9463 return self.then_construct_error(
9464 None,
9465 handle.node_id(),
9466 NodeKind::NonTerminal(handle.kind()),
9467 error,
9468 tree,
9469 );
9470 }
9471 };
9472 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9473 let result = match handle
9474 .get_view_with_visit(
9475 tree,
9476 |view, visit: &mut Self| {
9477 (
9478 if let Some(view) = view {
9479 visit.visit_strings_list(handle, view, tree)
9480 } else {
9481 Ok(())
9482 },
9483 visit,
9484 )
9485 },
9486 self,
9487 )
9488 .map_err(|e| e.extract_error())
9489 {
9490 Ok(Ok(())) => Ok(()),
9491 Ok(Err(e)) => Err(e),
9492 Err(Ok(e)) => Err(e),
9493 Err(Err(e)) => self.then_construct_error(
9494 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9495 handle.node_id(),
9496 NodeKind::NonTerminal(handle.kind()),
9497 e,
9498 tree,
9499 ),
9500 };
9501 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9502 result
9503 }
9504 fn visit_text_handle(&mut self, handle: TextHandle, tree: &F) -> Result<(), V::Error> {
9505 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9506 Ok(nt_data) => nt_data,
9507 Err(error) => {
9508 return self.then_construct_error(
9509 None,
9510 handle.node_id(),
9511 NodeKind::NonTerminal(handle.kind()),
9512 error,
9513 tree,
9514 );
9515 }
9516 };
9517 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9518 let result = match handle
9519 .get_view_with_visit(
9520 tree,
9521 |view, visit: &mut Self| (visit.visit_text(handle, view, tree), visit),
9522 self,
9523 )
9524 .map_err(|e| e.extract_error())
9525 {
9526 Ok(Ok(())) => Ok(()),
9527 Ok(Err(e)) => Err(e),
9528 Err(Ok(e)) => Err(e),
9529 Err(Err(e)) => self.then_construct_error(
9530 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9531 handle.node_id(),
9532 NodeKind::NonTerminal(handle.kind()),
9533 e,
9534 tree,
9535 ),
9536 };
9537 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9538 result
9539 }
9540 fn visit_text_binding_handle(
9541 &mut self,
9542 handle: TextBindingHandle,
9543 tree: &F,
9544 ) -> Result<(), V::Error> {
9545 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9546 Ok(nt_data) => nt_data,
9547 Err(error) => {
9548 return self.then_construct_error(
9549 None,
9550 handle.node_id(),
9551 NodeKind::NonTerminal(handle.kind()),
9552 error,
9553 tree,
9554 );
9555 }
9556 };
9557 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9558 let result = match handle
9559 .get_view_with_visit(
9560 tree,
9561 |view, visit: &mut Self| (visit.visit_text_binding(handle, view, tree), visit),
9562 self,
9563 )
9564 .map_err(|e| e.extract_error())
9565 {
9566 Ok(Ok(())) => Ok(()),
9567 Ok(Err(e)) => Err(e),
9568 Err(Ok(e)) => Err(e),
9569 Err(Err(e)) => self.then_construct_error(
9570 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9571 handle.node_id(),
9572 NodeKind::NonTerminal(handle.kind()),
9573 e,
9574 tree,
9575 ),
9576 };
9577 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9578 result
9579 }
9580 fn visit_text_binding_opt_handle(
9581 &mut self,
9582 handle: TextBindingOptHandle,
9583 tree: &F,
9584 ) -> Result<(), V::Error> {
9585 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9586 Ok(nt_data) => nt_data,
9587 Err(error) => {
9588 return self.then_construct_error(
9589 None,
9590 handle.node_id(),
9591 NodeKind::NonTerminal(handle.kind()),
9592 error,
9593 tree,
9594 );
9595 }
9596 };
9597 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9598 let result = match handle
9599 .get_view_with_visit(
9600 tree,
9601 |view, visit: &mut Self| {
9602 (
9603 if let Some(view) = view {
9604 visit.visit_text_binding_opt(handle, view, tree)
9605 } else {
9606 Ok(())
9607 },
9608 visit,
9609 )
9610 },
9611 self,
9612 )
9613 .map_err(|e| e.extract_error())
9614 {
9615 Ok(Ok(())) => Ok(()),
9616 Ok(Err(e)) => Err(e),
9617 Err(Ok(e)) => Err(e),
9618 Err(Err(e)) => self.then_construct_error(
9619 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9620 handle.node_id(),
9621 NodeKind::NonTerminal(handle.kind()),
9622 e,
9623 tree,
9624 ),
9625 };
9626 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9627 result
9628 }
9629 fn visit_text_binding_opt_0_handle(
9630 &mut self,
9631 handle: TextBindingOpt0Handle,
9632 tree: &F,
9633 ) -> Result<(), V::Error> {
9634 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9635 Ok(nt_data) => nt_data,
9636 Err(error) => {
9637 return self.then_construct_error(
9638 None,
9639 handle.node_id(),
9640 NodeKind::NonTerminal(handle.kind()),
9641 error,
9642 tree,
9643 );
9644 }
9645 };
9646 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9647 let result = match handle
9648 .get_view_with_visit(
9649 tree,
9650 |view, visit: &mut Self| {
9651 (
9652 if let Some(view) = view {
9653 visit.visit_text_binding_opt_0(handle, view, tree)
9654 } else {
9655 Ok(())
9656 },
9657 visit,
9658 )
9659 },
9660 self,
9661 )
9662 .map_err(|e| e.extract_error())
9663 {
9664 Ok(Ok(())) => Ok(()),
9665 Ok(Err(e)) => Err(e),
9666 Err(Ok(e)) => Err(e),
9667 Err(Err(e)) => self.then_construct_error(
9668 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9669 handle.node_id(),
9670 NodeKind::NonTerminal(handle.kind()),
9671 e,
9672 tree,
9673 ),
9674 };
9675 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9676 result
9677 }
9678 fn visit_text_binding_opt_1_handle(
9679 &mut self,
9680 handle: TextBindingOpt1Handle,
9681 tree: &F,
9682 ) -> Result<(), V::Error> {
9683 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9684 Ok(nt_data) => nt_data,
9685 Err(error) => {
9686 return self.then_construct_error(
9687 None,
9688 handle.node_id(),
9689 NodeKind::NonTerminal(handle.kind()),
9690 error,
9691 tree,
9692 );
9693 }
9694 };
9695 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9696 let result = match handle
9697 .get_view_with_visit(
9698 tree,
9699 |view, visit: &mut Self| {
9700 (
9701 if let Some(view) = view {
9702 visit.visit_text_binding_opt_1(handle, view, tree)
9703 } else {
9704 Ok(())
9705 },
9706 visit,
9707 )
9708 },
9709 self,
9710 )
9711 .map_err(|e| e.extract_error())
9712 {
9713 Ok(Ok(())) => Ok(()),
9714 Ok(Err(e)) => Err(e),
9715 Err(Ok(e)) => Err(e),
9716 Err(Err(e)) => self.then_construct_error(
9717 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9718 handle.node_id(),
9719 NodeKind::NonTerminal(handle.kind()),
9720 e,
9721 tree,
9722 ),
9723 };
9724 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9725 result
9726 }
9727 fn visit_text_start_handle(
9728 &mut self,
9729 handle: TextStartHandle,
9730 tree: &F,
9731 ) -> Result<(), V::Error> {
9732 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9733 Ok(nt_data) => nt_data,
9734 Err(error) => {
9735 return self.then_construct_error(
9736 None,
9737 handle.node_id(),
9738 NodeKind::NonTerminal(handle.kind()),
9739 error,
9740 tree,
9741 );
9742 }
9743 };
9744 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9745 let result = match handle
9746 .get_view_with_visit(
9747 tree,
9748 |view, visit: &mut Self| (visit.visit_text_start(handle, view, tree), visit),
9749 self,
9750 )
9751 .map_err(|e| e.extract_error())
9752 {
9753 Ok(Ok(())) => Ok(()),
9754 Ok(Err(e)) => Err(e),
9755 Err(Ok(e)) => Err(e),
9756 Err(Err(e)) => self.then_construct_error(
9757 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9758 handle.node_id(),
9759 NodeKind::NonTerminal(handle.kind()),
9760 e,
9761 tree,
9762 ),
9763 };
9764 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9765 result
9766 }
9767 fn visit_top_level_binding_handle(
9768 &mut self,
9769 handle: TopLevelBindingHandle,
9770 tree: &F,
9771 ) -> Result<(), V::Error> {
9772 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9773 Ok(nt_data) => nt_data,
9774 Err(error) => {
9775 return self.then_construct_error(
9776 None,
9777 handle.node_id(),
9778 NodeKind::NonTerminal(handle.kind()),
9779 error,
9780 tree,
9781 );
9782 }
9783 };
9784 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9785 let result = match handle
9786 .get_view_with_visit(
9787 tree,
9788 |view, visit: &mut Self| (visit.visit_top_level_binding(handle, view, tree), visit),
9789 self,
9790 )
9791 .map_err(|e| e.extract_error())
9792 {
9793 Ok(Ok(())) => Ok(()),
9794 Ok(Err(e)) => Err(e),
9795 Err(Ok(e)) => Err(e),
9796 Err(Err(e)) => self.then_construct_error(
9797 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9798 handle.node_id(),
9799 NodeKind::NonTerminal(handle.kind()),
9800 e,
9801 tree,
9802 ),
9803 };
9804 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9805 result
9806 }
9807 fn visit_true_handle(&mut self, handle: TrueHandle, tree: &F) -> Result<(), V::Error> {
9808 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9809 Ok(nt_data) => nt_data,
9810 Err(error) => {
9811 return self.then_construct_error(
9812 None,
9813 handle.node_id(),
9814 NodeKind::NonTerminal(handle.kind()),
9815 error,
9816 tree,
9817 );
9818 }
9819 };
9820 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9821 let result = match handle
9822 .get_view_with_visit(
9823 tree,
9824 |view, visit: &mut Self| (visit.visit_true(handle, view, tree), visit),
9825 self,
9826 )
9827 .map_err(|e| e.extract_error())
9828 {
9829 Ok(Ok(())) => Ok(()),
9830 Ok(Err(e)) => Err(e),
9831 Err(Ok(e)) => Err(e),
9832 Err(Err(e)) => self.then_construct_error(
9833 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9834 handle.node_id(),
9835 NodeKind::NonTerminal(handle.kind()),
9836 e,
9837 tree,
9838 ),
9839 };
9840 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9841 result
9842 }
9843 fn visit_tuple_handle(&mut self, handle: TupleHandle, tree: &F) -> Result<(), V::Error> {
9844 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9845 Ok(nt_data) => nt_data,
9846 Err(error) => {
9847 return self.then_construct_error(
9848 None,
9849 handle.node_id(),
9850 NodeKind::NonTerminal(handle.kind()),
9851 error,
9852 tree,
9853 );
9854 }
9855 };
9856 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9857 let result = match handle
9858 .get_view_with_visit(
9859 tree,
9860 |view, visit: &mut Self| (visit.visit_tuple(handle, view, tree), visit),
9861 self,
9862 )
9863 .map_err(|e| e.extract_error())
9864 {
9865 Ok(Ok(())) => Ok(()),
9866 Ok(Err(e)) => Err(e),
9867 Err(Ok(e)) => Err(e),
9868 Err(Err(e)) => self.then_construct_error(
9869 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9870 handle.node_id(),
9871 NodeKind::NonTerminal(handle.kind()),
9872 e,
9873 tree,
9874 ),
9875 };
9876 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9877 result
9878 }
9879 fn visit_tuple_elements_handle(
9880 &mut self,
9881 handle: TupleElementsHandle,
9882 tree: &F,
9883 ) -> Result<(), V::Error> {
9884 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9885 Ok(nt_data) => nt_data,
9886 Err(error) => {
9887 return self.then_construct_error(
9888 None,
9889 handle.node_id(),
9890 NodeKind::NonTerminal(handle.kind()),
9891 error,
9892 tree,
9893 );
9894 }
9895 };
9896 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9897 let result = match handle
9898 .get_view_with_visit(
9899 tree,
9900 |view, visit: &mut Self| (visit.visit_tuple_elements(handle, view, tree), visit),
9901 self,
9902 )
9903 .map_err(|e| e.extract_error())
9904 {
9905 Ok(Ok(())) => Ok(()),
9906 Ok(Err(e)) => Err(e),
9907 Err(Ok(e)) => Err(e),
9908 Err(Err(e)) => self.then_construct_error(
9909 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9910 handle.node_id(),
9911 NodeKind::NonTerminal(handle.kind()),
9912 e,
9913 tree,
9914 ),
9915 };
9916 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9917 result
9918 }
9919 fn visit_tuple_elements_opt_handle(
9920 &mut self,
9921 handle: TupleElementsOptHandle,
9922 tree: &F,
9923 ) -> Result<(), V::Error> {
9924 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9925 Ok(nt_data) => nt_data,
9926 Err(error) => {
9927 return self.then_construct_error(
9928 None,
9929 handle.node_id(),
9930 NodeKind::NonTerminal(handle.kind()),
9931 error,
9932 tree,
9933 );
9934 }
9935 };
9936 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9937 let result = match handle
9938 .get_view_with_visit(
9939 tree,
9940 |view, visit: &mut Self| {
9941 (
9942 if let Some(view) = view {
9943 visit.visit_tuple_elements_opt(handle, view, tree)
9944 } else {
9945 Ok(())
9946 },
9947 visit,
9948 )
9949 },
9950 self,
9951 )
9952 .map_err(|e| e.extract_error())
9953 {
9954 Ok(Ok(())) => Ok(()),
9955 Ok(Err(e)) => Err(e),
9956 Err(Ok(e)) => Err(e),
9957 Err(Err(e)) => self.then_construct_error(
9958 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
9959 handle.node_id(),
9960 NodeKind::NonTerminal(handle.kind()),
9961 e,
9962 tree,
9963 ),
9964 };
9965 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
9966 result
9967 }
9968 fn visit_tuple_elements_tail_handle(
9969 &mut self,
9970 handle: TupleElementsTailHandle,
9971 tree: &F,
9972 ) -> Result<(), V::Error> {
9973 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
9974 Ok(nt_data) => nt_data,
9975 Err(error) => {
9976 return self.then_construct_error(
9977 None,
9978 handle.node_id(),
9979 NodeKind::NonTerminal(handle.kind()),
9980 error,
9981 tree,
9982 );
9983 }
9984 };
9985 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
9986 let result = match handle
9987 .get_view_with_visit(
9988 tree,
9989 |view, visit: &mut Self| {
9990 (visit.visit_tuple_elements_tail(handle, view, tree), visit)
9991 },
9992 self,
9993 )
9994 .map_err(|e| e.extract_error())
9995 {
9996 Ok(Ok(())) => Ok(()),
9997 Ok(Err(e)) => Err(e),
9998 Err(Ok(e)) => Err(e),
9999 Err(Err(e)) => self.then_construct_error(
10000 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10001 handle.node_id(),
10002 NodeKind::NonTerminal(handle.kind()),
10003 e,
10004 tree,
10005 ),
10006 };
10007 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10008 result
10009 }
10010 fn visit_tuple_elements_tail_opt_handle(
10011 &mut self,
10012 handle: TupleElementsTailOptHandle,
10013 tree: &F,
10014 ) -> Result<(), V::Error> {
10015 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10016 Ok(nt_data) => nt_data,
10017 Err(error) => {
10018 return self.then_construct_error(
10019 None,
10020 handle.node_id(),
10021 NodeKind::NonTerminal(handle.kind()),
10022 error,
10023 tree,
10024 );
10025 }
10026 };
10027 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10028 let result = match handle
10029 .get_view_with_visit(
10030 tree,
10031 |view, visit: &mut Self| {
10032 (
10033 if let Some(view) = view {
10034 visit.visit_tuple_elements_tail_opt(handle, view, tree)
10035 } else {
10036 Ok(())
10037 },
10038 visit,
10039 )
10040 },
10041 self,
10042 )
10043 .map_err(|e| e.extract_error())
10044 {
10045 Ok(Ok(())) => Ok(()),
10046 Ok(Err(e)) => Err(e),
10047 Err(Ok(e)) => Err(e),
10048 Err(Err(e)) => self.then_construct_error(
10049 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10050 handle.node_id(),
10051 NodeKind::NonTerminal(handle.kind()),
10052 e,
10053 tree,
10054 ),
10055 };
10056 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10057 result
10058 }
10059 fn visit_tuple_index_handle(
10060 &mut self,
10061 handle: TupleIndexHandle,
10062 tree: &F,
10063 ) -> Result<(), V::Error> {
10064 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10065 Ok(nt_data) => nt_data,
10066 Err(error) => {
10067 return self.then_construct_error(
10068 None,
10069 handle.node_id(),
10070 NodeKind::NonTerminal(handle.kind()),
10071 error,
10072 tree,
10073 );
10074 }
10075 };
10076 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10077 let result = match handle
10078 .get_view_with_visit(
10079 tree,
10080 |view, visit: &mut Self| (visit.visit_tuple_index(handle, view, tree), visit),
10081 self,
10082 )
10083 .map_err(|e| e.extract_error())
10084 {
10085 Ok(Ok(())) => Ok(()),
10086 Ok(Err(e)) => Err(e),
10087 Err(Ok(e)) => Err(e),
10088 Err(Err(e)) => self.then_construct_error(
10089 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10090 handle.node_id(),
10091 NodeKind::NonTerminal(handle.kind()),
10092 e,
10093 tree,
10094 ),
10095 };
10096 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10097 result
10098 }
10099 fn visit_tuple_opt_handle(&mut self, handle: TupleOptHandle, tree: &F) -> Result<(), V::Error> {
10100 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10101 Ok(nt_data) => nt_data,
10102 Err(error) => {
10103 return self.then_construct_error(
10104 None,
10105 handle.node_id(),
10106 NodeKind::NonTerminal(handle.kind()),
10107 error,
10108 tree,
10109 );
10110 }
10111 };
10112 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10113 let result = match handle
10114 .get_view_with_visit(
10115 tree,
10116 |view, visit: &mut Self| {
10117 (
10118 if let Some(view) = view {
10119 visit.visit_tuple_opt(handle, view, tree)
10120 } else {
10121 Ok(())
10122 },
10123 visit,
10124 )
10125 },
10126 self,
10127 )
10128 .map_err(|e| e.extract_error())
10129 {
10130 Ok(Ok(())) => Ok(()),
10131 Ok(Err(e)) => Err(e),
10132 Err(Ok(e)) => Err(e),
10133 Err(Err(e)) => self.then_construct_error(
10134 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10135 handle.node_id(),
10136 NodeKind::NonTerminal(handle.kind()),
10137 e,
10138 tree,
10139 ),
10140 };
10141 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10142 result
10143 }
10144 fn visit_value_handle(&mut self, handle: ValueHandle, tree: &F) -> Result<(), V::Error> {
10145 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10146 Ok(nt_data) => nt_data,
10147 Err(error) => {
10148 return self.then_construct_error(
10149 None,
10150 handle.node_id(),
10151 NodeKind::NonTerminal(handle.kind()),
10152 error,
10153 tree,
10154 );
10155 }
10156 };
10157 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10158 let result = match handle
10159 .get_view_with_visit(
10160 tree,
10161 |view, visit: &mut Self| (visit.visit_value(handle, view, tree), visit),
10162 self,
10163 )
10164 .map_err(|e| e.extract_error())
10165 {
10166 Ok(Ok(())) => Ok(()),
10167 Ok(Err(e)) => Err(e),
10168 Err(Ok(e)) => Err(e),
10169 Err(Err(e)) => self.then_construct_error(
10170 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10171 handle.node_id(),
10172 NodeKind::NonTerminal(handle.kind()),
10173 e,
10174 tree,
10175 ),
10176 };
10177 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10178 result
10179 }
10180 fn visit_value_binding_handle(
10181 &mut self,
10182 handle: ValueBindingHandle,
10183 tree: &F,
10184 ) -> Result<(), V::Error> {
10185 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10186 Ok(nt_data) => nt_data,
10187 Err(error) => {
10188 return self.then_construct_error(
10189 None,
10190 handle.node_id(),
10191 NodeKind::NonTerminal(handle.kind()),
10192 error,
10193 tree,
10194 );
10195 }
10196 };
10197 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10198 let result = match handle
10199 .get_view_with_visit(
10200 tree,
10201 |view, visit: &mut Self| (visit.visit_value_binding(handle, view, tree), visit),
10202 self,
10203 )
10204 .map_err(|e| e.extract_error())
10205 {
10206 Ok(Ok(())) => Ok(()),
10207 Ok(Err(e)) => Err(e),
10208 Err(Ok(e)) => Err(e),
10209 Err(Err(e)) => self.then_construct_error(
10210 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10211 handle.node_id(),
10212 NodeKind::NonTerminal(handle.kind()),
10213 e,
10214 tree,
10215 ),
10216 };
10217 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10218 result
10219 }
10220 fn visit_ws_handle(&mut self, handle: WsHandle, tree: &F) -> Result<(), V::Error> {
10221 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10222 Ok(nt_data) => nt_data,
10223 Err(error) => {
10224 return self.then_construct_error(
10225 None,
10226 handle.node_id(),
10227 NodeKind::NonTerminal(handle.kind()),
10228 error,
10229 tree,
10230 );
10231 }
10232 };
10233 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10234 let result = match handle
10235 .get_view_with_visit(
10236 tree,
10237 |view, visit: &mut Self| (visit.visit_ws(handle, view, tree), visit),
10238 self,
10239 )
10240 .map_err(|e| e.extract_error())
10241 {
10242 Ok(Ok(())) => Ok(()),
10243 Ok(Err(e)) => Err(e),
10244 Err(Ok(e)) => Err(e),
10245 Err(Err(e)) => self.then_construct_error(
10246 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10247 handle.node_id(),
10248 NodeKind::NonTerminal(handle.kind()),
10249 e,
10250 tree,
10251 ),
10252 };
10253 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10254 result
10255 }
10256 fn visit_root_handle(&mut self, handle: RootHandle, tree: &F) -> Result<(), V::Error> {
10257 let nt_data = match tree.get_non_terminal(handle.node_id(), handle.kind()) {
10258 Ok(nt_data) => nt_data,
10259 Err(error) => {
10260 return self.then_construct_error(
10261 None,
10262 handle.node_id(),
10263 NodeKind::NonTerminal(handle.kind()),
10264 error,
10265 tree,
10266 );
10267 }
10268 };
10269 self.visit_non_terminal(handle.node_id(), handle.kind(), nt_data, tree)?;
10270 let result = match handle
10271 .get_view_with_visit(
10272 tree,
10273 |view, visit: &mut Self| (visit.visit_root(handle, view, tree), visit),
10274 self,
10275 )
10276 .map_err(|e| e.extract_error())
10277 {
10278 Ok(Ok(())) => Ok(()),
10279 Ok(Err(e)) => Err(e),
10280 Err(Ok(e)) => Err(e),
10281 Err(Err(e)) => self.then_construct_error(
10282 Some(CstNode::new_non_terminal(handle.kind(), nt_data)),
10283 handle.node_id(),
10284 NodeKind::NonTerminal(handle.kind()),
10285 e,
10286 tree,
10287 ),
10288 };
10289 self.visit_non_terminal_close(handle.node_id(), handle.kind(), nt_data, tree)?;
10290 result
10291 }
10292 fn visit_array_super(
10293 &mut self,
10294 handle: ArrayHandle,
10295 view_param: ArrayView,
10296 tree: &F,
10297 ) -> Result<(), V::Error> {
10298 let _handle = handle;
10299 let ArrayView {
10300 array_begin,
10301 array_opt,
10302 array_end,
10303 } = view_param;
10304 self.visit_array_begin_handle(array_begin, tree)?;
10305 self.visit_array_opt_handle(array_opt, tree)?;
10306 self.visit_array_end_handle(array_end, tree)?;
10307 Ok(())
10308 }
10309 fn visit_array_begin_super(
10310 &mut self,
10311 handle: ArrayBeginHandle,
10312 view_param: ArrayBeginView,
10313 tree: &F,
10314 ) -> Result<(), V::Error> {
10315 let _handle = handle;
10316 let ArrayBeginView { l_bracket } = view_param;
10317 let data = match l_bracket.get_data(tree) {
10318 Ok(data) => data,
10319 Err(error) => {
10320 return self.then_construct_error(
10321 None,
10322 l_bracket.0,
10323 NodeKind::Terminal(l_bracket.kind()),
10324 error,
10325 tree,
10326 );
10327 }
10328 };
10329 self.visit_l_bracket_terminal(l_bracket, data, tree)?;
10330 Ok(())
10331 }
10332 fn visit_array_elements_super(
10333 &mut self,
10334 handle: ArrayElementsHandle,
10335 view_param: ArrayElementsView,
10336 tree: &F,
10337 ) -> Result<(), V::Error> {
10338 let _handle = handle;
10339 let ArrayElementsView {
10340 value,
10341 array_elements_opt,
10342 } = view_param;
10343 self.visit_value_handle(value, tree)?;
10344 self.visit_array_elements_opt_handle(array_elements_opt, tree)?;
10345 Ok(())
10346 }
10347 fn visit_array_elements_opt_super(
10348 &mut self,
10349 handle: ArrayElementsOptHandle,
10350 view_param: ArrayElementsTailHandle,
10351 tree: &F,
10352 ) -> Result<(), V::Error> {
10353 let _handle = handle;
10354 self.visit_array_elements_tail_handle(view_param, tree)?;
10355 Ok(())
10356 }
10357 fn visit_array_elements_tail_super(
10358 &mut self,
10359 handle: ArrayElementsTailHandle,
10360 view_param: ArrayElementsTailView,
10361 tree: &F,
10362 ) -> Result<(), V::Error> {
10363 let _handle = handle;
10364 let ArrayElementsTailView {
10365 comma,
10366 array_elements_tail_opt,
10367 } = view_param;
10368 self.visit_comma_handle(comma, tree)?;
10369 self.visit_array_elements_tail_opt_handle(array_elements_tail_opt, tree)?;
10370 Ok(())
10371 }
10372 fn visit_array_elements_tail_opt_super(
10373 &mut self,
10374 handle: ArrayElementsTailOptHandle,
10375 view_param: ArrayElementsHandle,
10376 tree: &F,
10377 ) -> Result<(), V::Error> {
10378 let _handle = handle;
10379 self.visit_array_elements_handle(view_param, tree)?;
10380 Ok(())
10381 }
10382 fn visit_array_end_super(
10383 &mut self,
10384 handle: ArrayEndHandle,
10385 view_param: ArrayEndView,
10386 tree: &F,
10387 ) -> Result<(), V::Error> {
10388 let _handle = handle;
10389 let ArrayEndView { r_bracket } = view_param;
10390 let data = match r_bracket.get_data(tree) {
10391 Ok(data) => data,
10392 Err(error) => {
10393 return self.then_construct_error(
10394 None,
10395 r_bracket.0,
10396 NodeKind::Terminal(r_bracket.kind()),
10397 error,
10398 tree,
10399 );
10400 }
10401 };
10402 self.visit_r_bracket_terminal(r_bracket, data, tree)?;
10403 Ok(())
10404 }
10405 fn visit_array_marker_super(
10406 &mut self,
10407 handle: ArrayMarkerHandle,
10408 view_param: ArrayMarkerView,
10409 tree: &F,
10410 ) -> Result<(), V::Error> {
10411 let _handle = handle;
10412 let ArrayMarkerView {
10413 array_begin,
10414 array_marker_opt,
10415 array_end,
10416 } = view_param;
10417 self.visit_array_begin_handle(array_begin, tree)?;
10418 self.visit_array_marker_opt_handle(array_marker_opt, tree)?;
10419 self.visit_array_end_handle(array_end, tree)?;
10420 Ok(())
10421 }
10422 fn visit_array_marker_opt_super(
10423 &mut self,
10424 handle: ArrayMarkerOptHandle,
10425 view_param: IntegerHandle,
10426 tree: &F,
10427 ) -> Result<(), V::Error> {
10428 let _handle = handle;
10429 self.visit_integer_handle(view_param, tree)?;
10430 Ok(())
10431 }
10432 fn visit_array_opt_super(
10433 &mut self,
10434 handle: ArrayOptHandle,
10435 view_param: ArrayElementsHandle,
10436 tree: &F,
10437 ) -> Result<(), V::Error> {
10438 let _handle = handle;
10439 self.visit_array_elements_handle(view_param, tree)?;
10440 Ok(())
10441 }
10442 fn visit_at_super(
10443 &mut self,
10444 handle: AtHandle,
10445 view_param: AtView,
10446 tree: &F,
10447 ) -> Result<(), V::Error> {
10448 let _handle = handle;
10449 let AtView { at } = view_param;
10450 let data = match at.get_data(tree) {
10451 Ok(data) => data,
10452 Err(error) => {
10453 return self.then_construct_error(
10454 None,
10455 at.0,
10456 NodeKind::Terminal(at.kind()),
10457 error,
10458 tree,
10459 );
10460 }
10461 };
10462 self.visit_at_terminal(at, data, tree)?;
10463 Ok(())
10464 }
10465 fn visit_backtick_2_super(
10466 &mut self,
10467 handle: Backtick2Handle,
10468 view_param: Backtick2View,
10469 tree: &F,
10470 ) -> Result<(), V::Error> {
10471 let _handle = handle;
10472 let Backtick2View { backtick_2 } = view_param;
10473 let data = match backtick_2.get_data(tree) {
10474 Ok(data) => data,
10475 Err(error) => {
10476 return self.then_construct_error(
10477 None,
10478 backtick_2.0,
10479 NodeKind::Terminal(backtick_2.kind()),
10480 error,
10481 tree,
10482 );
10483 }
10484 };
10485 self.visit_backtick_2_terminal(backtick_2, data, tree)?;
10486 Ok(())
10487 }
10488 fn visit_backtick_3_super(
10489 &mut self,
10490 handle: Backtick3Handle,
10491 view_param: Backtick3View,
10492 tree: &F,
10493 ) -> Result<(), V::Error> {
10494 let _handle = handle;
10495 let Backtick3View { backtick_3 } = view_param;
10496 let data = match backtick_3.get_data(tree) {
10497 Ok(data) => data,
10498 Err(error) => {
10499 return self.then_construct_error(
10500 None,
10501 backtick_3.0,
10502 NodeKind::Terminal(backtick_3.kind()),
10503 error,
10504 tree,
10505 );
10506 }
10507 };
10508 self.visit_backtick_3_terminal(backtick_3, data, tree)?;
10509 Ok(())
10510 }
10511 fn visit_backtick_4_super(
10512 &mut self,
10513 handle: Backtick4Handle,
10514 view_param: Backtick4View,
10515 tree: &F,
10516 ) -> Result<(), V::Error> {
10517 let _handle = handle;
10518 let Backtick4View { backtick_4 } = view_param;
10519 let data = match backtick_4.get_data(tree) {
10520 Ok(data) => data,
10521 Err(error) => {
10522 return self.then_construct_error(
10523 None,
10524 backtick_4.0,
10525 NodeKind::Terminal(backtick_4.kind()),
10526 error,
10527 tree,
10528 );
10529 }
10530 };
10531 self.visit_backtick_4_terminal(backtick_4, data, tree)?;
10532 Ok(())
10533 }
10534 fn visit_backtick_5_super(
10535 &mut self,
10536 handle: Backtick5Handle,
10537 view_param: Backtick5View,
10538 tree: &F,
10539 ) -> Result<(), V::Error> {
10540 let _handle = handle;
10541 let Backtick5View { backtick_5 } = view_param;
10542 let data = match backtick_5.get_data(tree) {
10543 Ok(data) => data,
10544 Err(error) => {
10545 return self.then_construct_error(
10546 None,
10547 backtick_5.0,
10548 NodeKind::Terminal(backtick_5.kind()),
10549 error,
10550 tree,
10551 );
10552 }
10553 };
10554 self.visit_backtick_5_terminal(backtick_5, data, tree)?;
10555 Ok(())
10556 }
10557 fn visit_backtick_delim_super(
10558 &mut self,
10559 handle: BacktickDelimHandle,
10560 view_param: BacktickDelimView,
10561 tree: &F,
10562 ) -> Result<(), V::Error> {
10563 let _handle = handle;
10564 let BacktickDelimView { backtick_delim } = view_param;
10565 let data = match backtick_delim.get_data(tree) {
10566 Ok(data) => data,
10567 Err(error) => {
10568 return self.then_construct_error(
10569 None,
10570 backtick_delim.0,
10571 NodeKind::Terminal(backtick_delim.kind()),
10572 error,
10573 tree,
10574 );
10575 }
10576 };
10577 self.visit_backtick_delim_terminal(backtick_delim, data, tree)?;
10578 Ok(())
10579 }
10580 fn visit_begin_super(
10581 &mut self,
10582 handle: BeginHandle,
10583 view_param: BeginView,
10584 tree: &F,
10585 ) -> Result<(), V::Error> {
10586 let _handle = handle;
10587 let BeginView { l_brace } = view_param;
10588 let data = match l_brace.get_data(tree) {
10589 Ok(data) => data,
10590 Err(error) => {
10591 return self.then_construct_error(
10592 None,
10593 l_brace.0,
10594 NodeKind::Terminal(l_brace.kind()),
10595 error,
10596 tree,
10597 );
10598 }
10599 };
10600 self.visit_l_brace_terminal(l_brace, data, tree)?;
10601 Ok(())
10602 }
10603 fn visit_bind_super(
10604 &mut self,
10605 handle: BindHandle,
10606 view_param: BindView,
10607 tree: &F,
10608 ) -> Result<(), V::Error> {
10609 let _handle = handle;
10610 let BindView { bind } = view_param;
10611 let data = match bind.get_data(tree) {
10612 Ok(data) => data,
10613 Err(error) => {
10614 return self.then_construct_error(
10615 None,
10616 bind.0,
10617 NodeKind::Terminal(bind.kind()),
10618 error,
10619 tree,
10620 );
10621 }
10622 };
10623 self.visit_bind_terminal(bind, data, tree)?;
10624 Ok(())
10625 }
10626 fn visit_binding_super(
10627 &mut self,
10628 handle: BindingHandle,
10629 view_param: BindingView,
10630 tree: &F,
10631 ) -> Result<(), V::Error> {
10632 let _handle = handle;
10633 let BindingView { keys, binding_rhs } = view_param;
10634 self.visit_keys_handle(keys, tree)?;
10635 self.visit_binding_rhs_handle(binding_rhs, tree)?;
10636 Ok(())
10637 }
10638 fn visit_binding_rhs_super(
10639 &mut self,
10640 handle: BindingRhsHandle,
10641 view_param: BindingRhsView,
10642 tree: &F,
10643 ) -> Result<(), V::Error> {
10644 let _handle = handle;
10645 match view_param {
10646 BindingRhsView::ValueBinding(item) => {
10647 self.visit_value_binding_handle(item, tree)?;
10648 }
10649 BindingRhsView::SectionBinding(item) => {
10650 self.visit_section_binding_handle(item, tree)?;
10651 }
10652 BindingRhsView::TextBinding(item) => {
10653 self.visit_text_binding_handle(item, tree)?;
10654 }
10655 }
10656 Ok(())
10657 }
10658 fn visit_block_body_super(
10659 &mut self,
10660 handle: BlockBodyHandle,
10661 view_param: BlockBodyView,
10662 tree: &F,
10663 ) -> Result<(), V::Error> {
10664 let _handle = handle;
10665 let BlockBodyView { begin, eure, end } = view_param;
10666 self.visit_begin_handle(begin, tree)?;
10667 self.visit_eure_handle(eure, tree)?;
10668 self.visit_end_handle(end, tree)?;
10669 Ok(())
10670 }
10671 fn visit_boolean_super(
10672 &mut self,
10673 handle: BooleanHandle,
10674 view_param: BooleanView,
10675 tree: &F,
10676 ) -> Result<(), V::Error> {
10677 let _handle = handle;
10678 match view_param {
10679 BooleanView::True(item) => {
10680 self.visit_true_handle(item, tree)?;
10681 }
10682 BooleanView::False(item) => {
10683 self.visit_false_handle(item, tree)?;
10684 }
10685 }
10686 Ok(())
10687 }
10688 fn visit_code_block_super(
10689 &mut self,
10690 handle: CodeBlockHandle,
10691 view_param: CodeBlockView,
10692 tree: &F,
10693 ) -> Result<(), V::Error> {
10694 let _handle = handle;
10695 match view_param {
10696 CodeBlockView::CodeBlock3(item) => {
10697 self.visit_code_block_3_handle(item, tree)?;
10698 }
10699 CodeBlockView::CodeBlock4(item) => {
10700 self.visit_code_block_4_handle(item, tree)?;
10701 }
10702 CodeBlockView::CodeBlock5(item) => {
10703 self.visit_code_block_5_handle(item, tree)?;
10704 }
10705 CodeBlockView::CodeBlock6(item) => {
10706 self.visit_code_block_6_handle(item, tree)?;
10707 }
10708 }
10709 Ok(())
10710 }
10711 fn visit_code_block_3_super(
10712 &mut self,
10713 handle: CodeBlock3Handle,
10714 view_param: CodeBlock3View,
10715 tree: &F,
10716 ) -> Result<(), V::Error> {
10717 let _handle = handle;
10718 let CodeBlock3View {
10719 code_block_start_3,
10720 code_block_3_list,
10721 code_block_end_3,
10722 } = view_param;
10723 self.visit_code_block_start_3_handle(code_block_start_3, tree)?;
10724 self.visit_code_block_3_list_handle(code_block_3_list, tree)?;
10725 self.visit_code_block_end_3_handle(code_block_end_3, tree)?;
10726 Ok(())
10727 }
10728 fn visit_code_block_3_list_super(
10729 &mut self,
10730 handle: CodeBlock3ListHandle,
10731 view_param: CodeBlock3ListView,
10732 tree: &F,
10733 ) -> Result<(), V::Error> {
10734 let _handle = handle;
10735 let CodeBlock3ListView {
10736 code_block_3_list_group,
10737 code_block_3_list,
10738 } = view_param;
10739 self.visit_code_block_3_list_group_handle(code_block_3_list_group, tree)?;
10740 self.visit_code_block_3_list_handle(code_block_3_list, tree)?;
10741 Ok(())
10742 }
10743 fn visit_code_block_3_list_group_super(
10744 &mut self,
10745 handle: CodeBlock3ListGroupHandle,
10746 view_param: CodeBlock3ListGroupView,
10747 tree: &F,
10748 ) -> Result<(), V::Error> {
10749 let _handle = handle;
10750 match view_param {
10751 CodeBlock3ListGroupView::NoBacktick(item) => {
10752 self.visit_no_backtick_handle(item, tree)?;
10753 }
10754 CodeBlock3ListGroupView::Backtick2(item) => {
10755 self.visit_backtick_2_handle(item, tree)?;
10756 }
10757 }
10758 Ok(())
10759 }
10760 fn visit_code_block_4_super(
10761 &mut self,
10762 handle: CodeBlock4Handle,
10763 view_param: CodeBlock4View,
10764 tree: &F,
10765 ) -> Result<(), V::Error> {
10766 let _handle = handle;
10767 let CodeBlock4View {
10768 code_block_start_4,
10769 code_block_4_list,
10770 code_block_end_4,
10771 } = view_param;
10772 self.visit_code_block_start_4_handle(code_block_start_4, tree)?;
10773 self.visit_code_block_4_list_handle(code_block_4_list, tree)?;
10774 self.visit_code_block_end_4_handle(code_block_end_4, tree)?;
10775 Ok(())
10776 }
10777 fn visit_code_block_4_list_super(
10778 &mut self,
10779 handle: CodeBlock4ListHandle,
10780 view_param: CodeBlock4ListView,
10781 tree: &F,
10782 ) -> Result<(), V::Error> {
10783 let _handle = handle;
10784 let CodeBlock4ListView {
10785 code_block_4_list_group,
10786 code_block_4_list,
10787 } = view_param;
10788 self.visit_code_block_4_list_group_handle(code_block_4_list_group, tree)?;
10789 self.visit_code_block_4_list_handle(code_block_4_list, tree)?;
10790 Ok(())
10791 }
10792 fn visit_code_block_4_list_group_super(
10793 &mut self,
10794 handle: CodeBlock4ListGroupHandle,
10795 view_param: CodeBlock4ListGroupView,
10796 tree: &F,
10797 ) -> Result<(), V::Error> {
10798 let _handle = handle;
10799 match view_param {
10800 CodeBlock4ListGroupView::NoBacktick(item) => {
10801 self.visit_no_backtick_handle(item, tree)?;
10802 }
10803 CodeBlock4ListGroupView::Backtick3(item) => {
10804 self.visit_backtick_3_handle(item, tree)?;
10805 }
10806 }
10807 Ok(())
10808 }
10809 fn visit_code_block_5_super(
10810 &mut self,
10811 handle: CodeBlock5Handle,
10812 view_param: CodeBlock5View,
10813 tree: &F,
10814 ) -> Result<(), V::Error> {
10815 let _handle = handle;
10816 let CodeBlock5View {
10817 code_block_start_5,
10818 code_block_5_list,
10819 code_block_end_5,
10820 } = view_param;
10821 self.visit_code_block_start_5_handle(code_block_start_5, tree)?;
10822 self.visit_code_block_5_list_handle(code_block_5_list, tree)?;
10823 self.visit_code_block_end_5_handle(code_block_end_5, tree)?;
10824 Ok(())
10825 }
10826 fn visit_code_block_5_list_super(
10827 &mut self,
10828 handle: CodeBlock5ListHandle,
10829 view_param: CodeBlock5ListView,
10830 tree: &F,
10831 ) -> Result<(), V::Error> {
10832 let _handle = handle;
10833 let CodeBlock5ListView {
10834 code_block_5_list_group,
10835 code_block_5_list,
10836 } = view_param;
10837 self.visit_code_block_5_list_group_handle(code_block_5_list_group, tree)?;
10838 self.visit_code_block_5_list_handle(code_block_5_list, tree)?;
10839 Ok(())
10840 }
10841 fn visit_code_block_5_list_group_super(
10842 &mut self,
10843 handle: CodeBlock5ListGroupHandle,
10844 view_param: CodeBlock5ListGroupView,
10845 tree: &F,
10846 ) -> Result<(), V::Error> {
10847 let _handle = handle;
10848 match view_param {
10849 CodeBlock5ListGroupView::NoBacktick(item) => {
10850 self.visit_no_backtick_handle(item, tree)?;
10851 }
10852 CodeBlock5ListGroupView::Backtick4(item) => {
10853 self.visit_backtick_4_handle(item, tree)?;
10854 }
10855 }
10856 Ok(())
10857 }
10858 fn visit_code_block_6_super(
10859 &mut self,
10860 handle: CodeBlock6Handle,
10861 view_param: CodeBlock6View,
10862 tree: &F,
10863 ) -> Result<(), V::Error> {
10864 let _handle = handle;
10865 let CodeBlock6View {
10866 code_block_start_6,
10867 code_block_6_list,
10868 code_block_end_6,
10869 } = view_param;
10870 self.visit_code_block_start_6_handle(code_block_start_6, tree)?;
10871 self.visit_code_block_6_list_handle(code_block_6_list, tree)?;
10872 self.visit_code_block_end_6_handle(code_block_end_6, tree)?;
10873 Ok(())
10874 }
10875 fn visit_code_block_6_list_super(
10876 &mut self,
10877 handle: CodeBlock6ListHandle,
10878 view_param: CodeBlock6ListView,
10879 tree: &F,
10880 ) -> Result<(), V::Error> {
10881 let _handle = handle;
10882 let CodeBlock6ListView {
10883 code_block_6_list_group,
10884 code_block_6_list,
10885 } = view_param;
10886 self.visit_code_block_6_list_group_handle(code_block_6_list_group, tree)?;
10887 self.visit_code_block_6_list_handle(code_block_6_list, tree)?;
10888 Ok(())
10889 }
10890 fn visit_code_block_6_list_group_super(
10891 &mut self,
10892 handle: CodeBlock6ListGroupHandle,
10893 view_param: CodeBlock6ListGroupView,
10894 tree: &F,
10895 ) -> Result<(), V::Error> {
10896 let _handle = handle;
10897 match view_param {
10898 CodeBlock6ListGroupView::NoBacktick(item) => {
10899 self.visit_no_backtick_handle(item, tree)?;
10900 }
10901 CodeBlock6ListGroupView::Backtick5(item) => {
10902 self.visit_backtick_5_handle(item, tree)?;
10903 }
10904 }
10905 Ok(())
10906 }
10907 fn visit_code_block_end_3_super(
10908 &mut self,
10909 handle: CodeBlockEnd3Handle,
10910 view_param: CodeBlockEnd3View,
10911 tree: &F,
10912 ) -> Result<(), V::Error> {
10913 let _handle = handle;
10914 let CodeBlockEnd3View { code_block_end_3 } = view_param;
10915 let data = match code_block_end_3.get_data(tree) {
10916 Ok(data) => data,
10917 Err(error) => {
10918 return self.then_construct_error(
10919 None,
10920 code_block_end_3.0,
10921 NodeKind::Terminal(code_block_end_3.kind()),
10922 error,
10923 tree,
10924 );
10925 }
10926 };
10927 self.visit_code_block_end_3_terminal(code_block_end_3, data, tree)?;
10928 Ok(())
10929 }
10930 fn visit_code_block_end_4_super(
10931 &mut self,
10932 handle: CodeBlockEnd4Handle,
10933 view_param: CodeBlockEnd4View,
10934 tree: &F,
10935 ) -> Result<(), V::Error> {
10936 let _handle = handle;
10937 let CodeBlockEnd4View { code_block_end_4 } = view_param;
10938 let data = match code_block_end_4.get_data(tree) {
10939 Ok(data) => data,
10940 Err(error) => {
10941 return self.then_construct_error(
10942 None,
10943 code_block_end_4.0,
10944 NodeKind::Terminal(code_block_end_4.kind()),
10945 error,
10946 tree,
10947 );
10948 }
10949 };
10950 self.visit_code_block_end_4_terminal(code_block_end_4, data, tree)?;
10951 Ok(())
10952 }
10953 fn visit_code_block_end_5_super(
10954 &mut self,
10955 handle: CodeBlockEnd5Handle,
10956 view_param: CodeBlockEnd5View,
10957 tree: &F,
10958 ) -> Result<(), V::Error> {
10959 let _handle = handle;
10960 let CodeBlockEnd5View { code_block_end_5 } = view_param;
10961 let data = match code_block_end_5.get_data(tree) {
10962 Ok(data) => data,
10963 Err(error) => {
10964 return self.then_construct_error(
10965 None,
10966 code_block_end_5.0,
10967 NodeKind::Terminal(code_block_end_5.kind()),
10968 error,
10969 tree,
10970 );
10971 }
10972 };
10973 self.visit_code_block_end_5_terminal(code_block_end_5, data, tree)?;
10974 Ok(())
10975 }
10976 fn visit_code_block_end_6_super(
10977 &mut self,
10978 handle: CodeBlockEnd6Handle,
10979 view_param: CodeBlockEnd6View,
10980 tree: &F,
10981 ) -> Result<(), V::Error> {
10982 let _handle = handle;
10983 let CodeBlockEnd6View { code_block_end_6 } = view_param;
10984 let data = match code_block_end_6.get_data(tree) {
10985 Ok(data) => data,
10986 Err(error) => {
10987 return self.then_construct_error(
10988 None,
10989 code_block_end_6.0,
10990 NodeKind::Terminal(code_block_end_6.kind()),
10991 error,
10992 tree,
10993 );
10994 }
10995 };
10996 self.visit_code_block_end_6_terminal(code_block_end_6, data, tree)?;
10997 Ok(())
10998 }
10999 fn visit_code_block_start_3_super(
11000 &mut self,
11001 handle: CodeBlockStart3Handle,
11002 view_param: CodeBlockStart3View,
11003 tree: &F,
11004 ) -> Result<(), V::Error> {
11005 let _handle = handle;
11006 let CodeBlockStart3View { code_block_start_3 } = view_param;
11007 let data = match code_block_start_3.get_data(tree) {
11008 Ok(data) => data,
11009 Err(error) => {
11010 return self.then_construct_error(
11011 None,
11012 code_block_start_3.0,
11013 NodeKind::Terminal(code_block_start_3.kind()),
11014 error,
11015 tree,
11016 );
11017 }
11018 };
11019 self.visit_code_block_start_3_terminal(code_block_start_3, data, tree)?;
11020 Ok(())
11021 }
11022 fn visit_code_block_start_4_super(
11023 &mut self,
11024 handle: CodeBlockStart4Handle,
11025 view_param: CodeBlockStart4View,
11026 tree: &F,
11027 ) -> Result<(), V::Error> {
11028 let _handle = handle;
11029 let CodeBlockStart4View { code_block_start_4 } = view_param;
11030 let data = match code_block_start_4.get_data(tree) {
11031 Ok(data) => data,
11032 Err(error) => {
11033 return self.then_construct_error(
11034 None,
11035 code_block_start_4.0,
11036 NodeKind::Terminal(code_block_start_4.kind()),
11037 error,
11038 tree,
11039 );
11040 }
11041 };
11042 self.visit_code_block_start_4_terminal(code_block_start_4, data, tree)?;
11043 Ok(())
11044 }
11045 fn visit_code_block_start_5_super(
11046 &mut self,
11047 handle: CodeBlockStart5Handle,
11048 view_param: CodeBlockStart5View,
11049 tree: &F,
11050 ) -> Result<(), V::Error> {
11051 let _handle = handle;
11052 let CodeBlockStart5View { code_block_start_5 } = view_param;
11053 let data = match code_block_start_5.get_data(tree) {
11054 Ok(data) => data,
11055 Err(error) => {
11056 return self.then_construct_error(
11057 None,
11058 code_block_start_5.0,
11059 NodeKind::Terminal(code_block_start_5.kind()),
11060 error,
11061 tree,
11062 );
11063 }
11064 };
11065 self.visit_code_block_start_5_terminal(code_block_start_5, data, tree)?;
11066 Ok(())
11067 }
11068 fn visit_code_block_start_6_super(
11069 &mut self,
11070 handle: CodeBlockStart6Handle,
11071 view_param: CodeBlockStart6View,
11072 tree: &F,
11073 ) -> Result<(), V::Error> {
11074 let _handle = handle;
11075 let CodeBlockStart6View { code_block_start_6 } = view_param;
11076 let data = match code_block_start_6.get_data(tree) {
11077 Ok(data) => data,
11078 Err(error) => {
11079 return self.then_construct_error(
11080 None,
11081 code_block_start_6.0,
11082 NodeKind::Terminal(code_block_start_6.kind()),
11083 error,
11084 tree,
11085 );
11086 }
11087 };
11088 self.visit_code_block_start_6_terminal(code_block_start_6, data, tree)?;
11089 Ok(())
11090 }
11091 fn visit_comma_super(
11092 &mut self,
11093 handle: CommaHandle,
11094 view_param: CommaView,
11095 tree: &F,
11096 ) -> Result<(), V::Error> {
11097 let _handle = handle;
11098 let CommaView { comma } = view_param;
11099 let data = match comma.get_data(tree) {
11100 Ok(data) => data,
11101 Err(error) => {
11102 return self.then_construct_error(
11103 None,
11104 comma.0,
11105 NodeKind::Terminal(comma.kind()),
11106 error,
11107 tree,
11108 );
11109 }
11110 };
11111 self.visit_comma_terminal(comma, data, tree)?;
11112 Ok(())
11113 }
11114 fn visit_continue_super(
11115 &mut self,
11116 handle: ContinueHandle,
11117 view_param: ContinueView,
11118 tree: &F,
11119 ) -> Result<(), V::Error> {
11120 let _handle = handle;
11121 let ContinueView { esc } = view_param;
11122 let data = match esc.get_data(tree) {
11123 Ok(data) => data,
11124 Err(error) => {
11125 return self.then_construct_error(
11126 None,
11127 esc.0,
11128 NodeKind::Terminal(esc.kind()),
11129 error,
11130 tree,
11131 );
11132 }
11133 };
11134 self.visit_esc_terminal(esc, data, tree)?;
11135 Ok(())
11136 }
11137 fn visit_delim_code_super(
11138 &mut self,
11139 handle: DelimCodeHandle,
11140 view_param: DelimCodeView,
11141 tree: &F,
11142 ) -> Result<(), V::Error> {
11143 let _handle = handle;
11144 match view_param {
11145 DelimCodeView::DelimCode3(item) => {
11146 self.visit_delim_code_3_handle(item, tree)?;
11147 }
11148 DelimCodeView::DelimCode2(item) => {
11149 self.visit_delim_code_2_handle(item, tree)?;
11150 }
11151 DelimCodeView::DelimCode1(item) => {
11152 self.visit_delim_code_1_handle(item, tree)?;
11153 }
11154 }
11155 Ok(())
11156 }
11157 fn visit_delim_code_1_super(
11158 &mut self,
11159 handle: DelimCode1Handle,
11160 view_param: DelimCode1View,
11161 tree: &F,
11162 ) -> Result<(), V::Error> {
11163 let _handle = handle;
11164 let DelimCode1View {
11165 delim_code_start_1,
11166 delim_code_1_list,
11167 delim_code_end_1,
11168 } = view_param;
11169 self.visit_delim_code_start_1_handle(delim_code_start_1, tree)?;
11170 self.visit_delim_code_1_list_handle(delim_code_1_list, tree)?;
11171 self.visit_delim_code_end_1_handle(delim_code_end_1, tree)?;
11172 Ok(())
11173 }
11174 fn visit_delim_code_1_list_super(
11175 &mut self,
11176 handle: DelimCode1ListHandle,
11177 view_param: DelimCode1ListView,
11178 tree: &F,
11179 ) -> Result<(), V::Error> {
11180 let _handle = handle;
11181 let DelimCode1ListView {
11182 delim_code_1_list_group,
11183 delim_code_1_list,
11184 } = view_param;
11185 self.visit_delim_code_1_list_group_handle(delim_code_1_list_group, tree)?;
11186 self.visit_delim_code_1_list_handle(delim_code_1_list, tree)?;
11187 Ok(())
11188 }
11189 fn visit_delim_code_1_list_group_super(
11190 &mut self,
11191 handle: DelimCode1ListGroupHandle,
11192 view_param: DelimCode1ListGroupView,
11193 tree: &F,
11194 ) -> Result<(), V::Error> {
11195 let _handle = handle;
11196 match view_param {
11197 DelimCode1ListGroupView::NoBacktick(item) => {
11198 self.visit_no_backtick_handle(item, tree)?;
11199 }
11200 DelimCode1ListGroupView::BacktickDelim(item) => {
11201 self.visit_backtick_delim_handle(item, tree)?;
11202 }
11203 }
11204 Ok(())
11205 }
11206 fn visit_delim_code_2_super(
11207 &mut self,
11208 handle: DelimCode2Handle,
11209 view_param: DelimCode2View,
11210 tree: &F,
11211 ) -> Result<(), V::Error> {
11212 let _handle = handle;
11213 let DelimCode2View {
11214 delim_code_start_2,
11215 delim_code_2_list,
11216 delim_code_end_2,
11217 } = view_param;
11218 self.visit_delim_code_start_2_handle(delim_code_start_2, tree)?;
11219 self.visit_delim_code_2_list_handle(delim_code_2_list, tree)?;
11220 self.visit_delim_code_end_2_handle(delim_code_end_2, tree)?;
11221 Ok(())
11222 }
11223 fn visit_delim_code_2_list_super(
11224 &mut self,
11225 handle: DelimCode2ListHandle,
11226 view_param: DelimCode2ListView,
11227 tree: &F,
11228 ) -> Result<(), V::Error> {
11229 let _handle = handle;
11230 let DelimCode2ListView {
11231 delim_code_2_list_group,
11232 delim_code_2_list,
11233 } = view_param;
11234 self.visit_delim_code_2_list_group_handle(delim_code_2_list_group, tree)?;
11235 self.visit_delim_code_2_list_handle(delim_code_2_list, tree)?;
11236 Ok(())
11237 }
11238 fn visit_delim_code_2_list_group_super(
11239 &mut self,
11240 handle: DelimCode2ListGroupHandle,
11241 view_param: DelimCode2ListGroupView,
11242 tree: &F,
11243 ) -> Result<(), V::Error> {
11244 let _handle = handle;
11245 match view_param {
11246 DelimCode2ListGroupView::NoBacktick(item) => {
11247 self.visit_no_backtick_handle(item, tree)?;
11248 }
11249 DelimCode2ListGroupView::BacktickDelim(item) => {
11250 self.visit_backtick_delim_handle(item, tree)?;
11251 }
11252 }
11253 Ok(())
11254 }
11255 fn visit_delim_code_3_super(
11256 &mut self,
11257 handle: DelimCode3Handle,
11258 view_param: DelimCode3View,
11259 tree: &F,
11260 ) -> Result<(), V::Error> {
11261 let _handle = handle;
11262 let DelimCode3View {
11263 delim_code_start_3,
11264 delim_code_3_list,
11265 delim_code_end_3,
11266 } = view_param;
11267 self.visit_delim_code_start_3_handle(delim_code_start_3, tree)?;
11268 self.visit_delim_code_3_list_handle(delim_code_3_list, tree)?;
11269 self.visit_delim_code_end_3_handle(delim_code_end_3, tree)?;
11270 Ok(())
11271 }
11272 fn visit_delim_code_3_list_super(
11273 &mut self,
11274 handle: DelimCode3ListHandle,
11275 view_param: DelimCode3ListView,
11276 tree: &F,
11277 ) -> Result<(), V::Error> {
11278 let _handle = handle;
11279 let DelimCode3ListView {
11280 delim_code_3_list_group,
11281 delim_code_3_list,
11282 } = view_param;
11283 self.visit_delim_code_3_list_group_handle(delim_code_3_list_group, tree)?;
11284 self.visit_delim_code_3_list_handle(delim_code_3_list, tree)?;
11285 Ok(())
11286 }
11287 fn visit_delim_code_3_list_group_super(
11288 &mut self,
11289 handle: DelimCode3ListGroupHandle,
11290 view_param: DelimCode3ListGroupView,
11291 tree: &F,
11292 ) -> Result<(), V::Error> {
11293 let _handle = handle;
11294 match view_param {
11295 DelimCode3ListGroupView::NoBacktick(item) => {
11296 self.visit_no_backtick_handle(item, tree)?;
11297 }
11298 DelimCode3ListGroupView::BacktickDelim(item) => {
11299 self.visit_backtick_delim_handle(item, tree)?;
11300 }
11301 }
11302 Ok(())
11303 }
11304 fn visit_delim_code_end_1_super(
11305 &mut self,
11306 handle: DelimCodeEnd1Handle,
11307 view_param: DelimCodeEnd1View,
11308 tree: &F,
11309 ) -> Result<(), V::Error> {
11310 let _handle = handle;
11311 let DelimCodeEnd1View { delim_code_end_1 } = view_param;
11312 let data = match delim_code_end_1.get_data(tree) {
11313 Ok(data) => data,
11314 Err(error) => {
11315 return self.then_construct_error(
11316 None,
11317 delim_code_end_1.0,
11318 NodeKind::Terminal(delim_code_end_1.kind()),
11319 error,
11320 tree,
11321 );
11322 }
11323 };
11324 self.visit_delim_code_end_1_terminal(delim_code_end_1, data, tree)?;
11325 Ok(())
11326 }
11327 fn visit_delim_code_end_2_super(
11328 &mut self,
11329 handle: DelimCodeEnd2Handle,
11330 view_param: DelimCodeEnd2View,
11331 tree: &F,
11332 ) -> Result<(), V::Error> {
11333 let _handle = handle;
11334 let DelimCodeEnd2View { delim_code_end_2 } = view_param;
11335 let data = match delim_code_end_2.get_data(tree) {
11336 Ok(data) => data,
11337 Err(error) => {
11338 return self.then_construct_error(
11339 None,
11340 delim_code_end_2.0,
11341 NodeKind::Terminal(delim_code_end_2.kind()),
11342 error,
11343 tree,
11344 );
11345 }
11346 };
11347 self.visit_delim_code_end_2_terminal(delim_code_end_2, data, tree)?;
11348 Ok(())
11349 }
11350 fn visit_delim_code_end_3_super(
11351 &mut self,
11352 handle: DelimCodeEnd3Handle,
11353 view_param: DelimCodeEnd3View,
11354 tree: &F,
11355 ) -> Result<(), V::Error> {
11356 let _handle = handle;
11357 let DelimCodeEnd3View { delim_code_end_3 } = view_param;
11358 let data = match delim_code_end_3.get_data(tree) {
11359 Ok(data) => data,
11360 Err(error) => {
11361 return self.then_construct_error(
11362 None,
11363 delim_code_end_3.0,
11364 NodeKind::Terminal(delim_code_end_3.kind()),
11365 error,
11366 tree,
11367 );
11368 }
11369 };
11370 self.visit_delim_code_end_3_terminal(delim_code_end_3, data, tree)?;
11371 Ok(())
11372 }
11373 fn visit_delim_code_start_1_super(
11374 &mut self,
11375 handle: DelimCodeStart1Handle,
11376 view_param: DelimCodeStart1View,
11377 tree: &F,
11378 ) -> Result<(), V::Error> {
11379 let _handle = handle;
11380 let DelimCodeStart1View { delim_code_start_1 } = view_param;
11381 let data = match delim_code_start_1.get_data(tree) {
11382 Ok(data) => data,
11383 Err(error) => {
11384 return self.then_construct_error(
11385 None,
11386 delim_code_start_1.0,
11387 NodeKind::Terminal(delim_code_start_1.kind()),
11388 error,
11389 tree,
11390 );
11391 }
11392 };
11393 self.visit_delim_code_start_1_terminal(delim_code_start_1, data, tree)?;
11394 Ok(())
11395 }
11396 fn visit_delim_code_start_2_super(
11397 &mut self,
11398 handle: DelimCodeStart2Handle,
11399 view_param: DelimCodeStart2View,
11400 tree: &F,
11401 ) -> Result<(), V::Error> {
11402 let _handle = handle;
11403 let DelimCodeStart2View { delim_code_start_2 } = view_param;
11404 let data = match delim_code_start_2.get_data(tree) {
11405 Ok(data) => data,
11406 Err(error) => {
11407 return self.then_construct_error(
11408 None,
11409 delim_code_start_2.0,
11410 NodeKind::Terminal(delim_code_start_2.kind()),
11411 error,
11412 tree,
11413 );
11414 }
11415 };
11416 self.visit_delim_code_start_2_terminal(delim_code_start_2, data, tree)?;
11417 Ok(())
11418 }
11419 fn visit_delim_code_start_3_super(
11420 &mut self,
11421 handle: DelimCodeStart3Handle,
11422 view_param: DelimCodeStart3View,
11423 tree: &F,
11424 ) -> Result<(), V::Error> {
11425 let _handle = handle;
11426 let DelimCodeStart3View { delim_code_start_3 } = view_param;
11427 let data = match delim_code_start_3.get_data(tree) {
11428 Ok(data) => data,
11429 Err(error) => {
11430 return self.then_construct_error(
11431 None,
11432 delim_code_start_3.0,
11433 NodeKind::Terminal(delim_code_start_3.kind()),
11434 error,
11435 tree,
11436 );
11437 }
11438 };
11439 self.visit_delim_code_start_3_terminal(delim_code_start_3, data, tree)?;
11440 Ok(())
11441 }
11442 fn visit_dot_super(
11443 &mut self,
11444 handle: DotHandle,
11445 view_param: DotView,
11446 tree: &F,
11447 ) -> Result<(), V::Error> {
11448 let _handle = handle;
11449 let DotView { dot } = view_param;
11450 let data = match dot.get_data(tree) {
11451 Ok(data) => data,
11452 Err(error) => {
11453 return self.then_construct_error(
11454 None,
11455 dot.0,
11456 NodeKind::Terminal(dot.kind()),
11457 error,
11458 tree,
11459 );
11460 }
11461 };
11462 self.visit_dot_terminal(dot, data, tree)?;
11463 Ok(())
11464 }
11465 fn visit_dot_key_super(
11466 &mut self,
11467 handle: DotKeyHandle,
11468 view_param: DotKeyView,
11469 tree: &F,
11470 ) -> Result<(), V::Error> {
11471 let _handle = handle;
11472 let DotKeyView { dot, key } = view_param;
11473 self.visit_dot_handle(dot, tree)?;
11474 self.visit_key_handle(key, tree)?;
11475 Ok(())
11476 }
11477 fn visit_end_super(
11478 &mut self,
11479 handle: EndHandle,
11480 view_param: EndView,
11481 tree: &F,
11482 ) -> Result<(), V::Error> {
11483 let _handle = handle;
11484 let EndView { r_brace } = view_param;
11485 let data = match r_brace.get_data(tree) {
11486 Ok(data) => data,
11487 Err(error) => {
11488 return self.then_construct_error(
11489 None,
11490 r_brace.0,
11491 NodeKind::Terminal(r_brace.kind()),
11492 error,
11493 tree,
11494 );
11495 }
11496 };
11497 self.visit_r_brace_terminal(r_brace, data, tree)?;
11498 Ok(())
11499 }
11500 fn visit_eure_super(
11501 &mut self,
11502 handle: EureHandle,
11503 view_param: EureView,
11504 tree: &F,
11505 ) -> Result<(), V::Error> {
11506 let _handle = handle;
11507 let EureView {
11508 eure_opt,
11509 eure_bindings,
11510 eure_sections,
11511 } = view_param;
11512 self.visit_eure_opt_handle(eure_opt, tree)?;
11513 self.visit_eure_bindings_handle(eure_bindings, tree)?;
11514 self.visit_eure_sections_handle(eure_sections, tree)?;
11515 Ok(())
11516 }
11517 fn visit_eure_bindings_super(
11518 &mut self,
11519 handle: EureBindingsHandle,
11520 view_param: EureBindingsView,
11521 tree: &F,
11522 ) -> Result<(), V::Error> {
11523 let _handle = handle;
11524 let EureBindingsView {
11525 binding,
11526 eure_bindings,
11527 } = view_param;
11528 self.visit_binding_handle(binding, tree)?;
11529 self.visit_eure_bindings_handle(eure_bindings, tree)?;
11530 Ok(())
11531 }
11532 fn visit_eure_sections_super(
11533 &mut self,
11534 handle: EureSectionsHandle,
11535 view_param: EureSectionsView,
11536 tree: &F,
11537 ) -> Result<(), V::Error> {
11538 let _handle = handle;
11539 let EureSectionsView {
11540 section,
11541 eure_sections,
11542 } = view_param;
11543 self.visit_section_handle(section, tree)?;
11544 self.visit_eure_sections_handle(eure_sections, tree)?;
11545 Ok(())
11546 }
11547 fn visit_eure_opt_super(
11548 &mut self,
11549 handle: EureOptHandle,
11550 view_param: TopLevelBindingHandle,
11551 tree: &F,
11552 ) -> Result<(), V::Error> {
11553 let _handle = handle;
11554 self.visit_top_level_binding_handle(view_param, tree)?;
11555 Ok(())
11556 }
11557 fn visit_ext_super(
11558 &mut self,
11559 handle: ExtHandle,
11560 view_param: ExtView,
11561 tree: &F,
11562 ) -> Result<(), V::Error> {
11563 let _handle = handle;
11564 let ExtView { dollar } = view_param;
11565 let data = match dollar.get_data(tree) {
11566 Ok(data) => data,
11567 Err(error) => {
11568 return self.then_construct_error(
11569 None,
11570 dollar.0,
11571 NodeKind::Terminal(dollar.kind()),
11572 error,
11573 tree,
11574 );
11575 }
11576 };
11577 self.visit_dollar_terminal(dollar, data, tree)?;
11578 Ok(())
11579 }
11580 fn visit_extension_name_space_super(
11581 &mut self,
11582 handle: ExtensionNameSpaceHandle,
11583 view_param: ExtensionNameSpaceView,
11584 tree: &F,
11585 ) -> Result<(), V::Error> {
11586 let _handle = handle;
11587 let ExtensionNameSpaceView { ext, key_ident } = view_param;
11588 self.visit_ext_handle(ext, tree)?;
11589 self.visit_key_ident_handle(key_ident, tree)?;
11590 Ok(())
11591 }
11592 fn visit_false_super(
11593 &mut self,
11594 handle: FalseHandle,
11595 view_param: FalseView,
11596 tree: &F,
11597 ) -> Result<(), V::Error> {
11598 let _handle = handle;
11599 let FalseView { r#false } = view_param;
11600 let data = match r#false.get_data(tree) {
11601 Ok(data) => data,
11602 Err(error) => {
11603 return self.then_construct_error(
11604 None,
11605 r#false.0,
11606 NodeKind::Terminal(r#false.kind()),
11607 error,
11608 tree,
11609 );
11610 }
11611 };
11612 self.visit_false_terminal(r#false, data, tree)?;
11613 Ok(())
11614 }
11615 fn visit_first_key_super(
11616 &mut self,
11617 handle: FirstKeyHandle,
11618 view_param: FirstKeyView,
11619 tree: &F,
11620 ) -> Result<(), V::Error> {
11621 let _handle = handle;
11622 match view_param {
11623 FirstKeyView::Key(item) => {
11624 self.visit_key_handle(item, tree)?;
11625 }
11626 FirstKeyView::ArrayMarker(item) => {
11627 self.visit_array_marker_handle(item, tree)?;
11628 }
11629 }
11630 Ok(())
11631 }
11632 fn visit_flat_body_super(
11633 &mut self,
11634 handle: FlatBodyHandle,
11635 view_param: FlatBodyView,
11636 tree: &F,
11637 ) -> Result<(), V::Error> {
11638 let _handle = handle;
11639 let FlatBodyView {
11640 section_head,
11641 flat_body_list,
11642 } = view_param;
11643 self.visit_section_head_handle(section_head, tree)?;
11644 self.visit_flat_body_list_handle(flat_body_list, tree)?;
11645 Ok(())
11646 }
11647 fn visit_flat_body_list_super(
11648 &mut self,
11649 handle: FlatBodyListHandle,
11650 view_param: FlatBodyListView,
11651 tree: &F,
11652 ) -> Result<(), V::Error> {
11653 let _handle = handle;
11654 let FlatBodyListView {
11655 binding,
11656 flat_body_list,
11657 } = view_param;
11658 self.visit_binding_handle(binding, tree)?;
11659 self.visit_flat_body_list_handle(flat_body_list, tree)?;
11660 Ok(())
11661 }
11662 fn visit_flat_root_binding_super(
11663 &mut self,
11664 handle: FlatRootBindingHandle,
11665 view_param: FlatRootBindingView,
11666 tree: &F,
11667 ) -> Result<(), V::Error> {
11668 let _handle = handle;
11669 match view_param {
11670 FlatRootBindingView::ValueBinding(item) => {
11671 self.visit_value_binding_handle(item, tree)?;
11672 }
11673 FlatRootBindingView::TextBinding(item) => {
11674 self.visit_text_binding_handle(item, tree)?;
11675 }
11676 }
11677 Ok(())
11678 }
11679 fn visit_float_super(
11680 &mut self,
11681 handle: FloatHandle,
11682 view_param: FloatView,
11683 tree: &F,
11684 ) -> Result<(), V::Error> {
11685 let _handle = handle;
11686 let FloatView { float } = view_param;
11687 let data = match float.get_data(tree) {
11688 Ok(data) => data,
11689 Err(error) => {
11690 return self.then_construct_error(
11691 None,
11692 float.0,
11693 NodeKind::Terminal(float.kind()),
11694 error,
11695 tree,
11696 );
11697 }
11698 };
11699 self.visit_float_terminal(float, data, tree)?;
11700 Ok(())
11701 }
11702 fn visit_grammar_newline_super(
11703 &mut self,
11704 handle: GrammarNewlineHandle,
11705 view_param: GrammarNewlineView,
11706 tree: &F,
11707 ) -> Result<(), V::Error> {
11708 let _handle = handle;
11709 let GrammarNewlineView { grammar_newline } = view_param;
11710 let data = match grammar_newline.get_data(tree) {
11711 Ok(data) => data,
11712 Err(error) => {
11713 return self.then_construct_error(
11714 None,
11715 grammar_newline.0,
11716 NodeKind::Terminal(grammar_newline.kind()),
11717 error,
11718 tree,
11719 );
11720 }
11721 };
11722 self.visit_grammar_newline_terminal(grammar_newline, data, tree)?;
11723 Ok(())
11724 }
11725 fn visit_hole_super(
11726 &mut self,
11727 handle: HoleHandle,
11728 view_param: HoleView,
11729 tree: &F,
11730 ) -> Result<(), V::Error> {
11731 let _handle = handle;
11732 let HoleView { hole } = view_param;
11733 let data = match hole.get_data(tree) {
11734 Ok(data) => data,
11735 Err(error) => {
11736 return self.then_construct_error(
11737 None,
11738 hole.0,
11739 NodeKind::Terminal(hole.kind()),
11740 error,
11741 tree,
11742 );
11743 }
11744 };
11745 self.visit_hole_terminal(hole, data, tree)?;
11746 Ok(())
11747 }
11748 fn visit_ident_super(
11749 &mut self,
11750 handle: IdentHandle,
11751 view_param: IdentView,
11752 tree: &F,
11753 ) -> Result<(), V::Error> {
11754 let _handle = handle;
11755 let IdentView { ident } = view_param;
11756 let data = match ident.get_data(tree) {
11757 Ok(data) => data,
11758 Err(error) => {
11759 return self.then_construct_error(
11760 None,
11761 ident.0,
11762 NodeKind::Terminal(ident.kind()),
11763 error,
11764 tree,
11765 );
11766 }
11767 };
11768 self.visit_ident_terminal(ident, data, tree)?;
11769 Ok(())
11770 }
11771 fn visit_inf_super(
11772 &mut self,
11773 handle: InfHandle,
11774 view_param: InfView,
11775 tree: &F,
11776 ) -> Result<(), V::Error> {
11777 let _handle = handle;
11778 let InfView { inf } = view_param;
11779 let data = match inf.get_data(tree) {
11780 Ok(data) => data,
11781 Err(error) => {
11782 return self.then_construct_error(
11783 None,
11784 inf.0,
11785 NodeKind::Terminal(inf.kind()),
11786 error,
11787 tree,
11788 );
11789 }
11790 };
11791 self.visit_inf_terminal(inf, data, tree)?;
11792 Ok(())
11793 }
11794 fn visit_inline_code_super(
11795 &mut self,
11796 handle: InlineCodeHandle,
11797 view_param: InlineCodeView,
11798 tree: &F,
11799 ) -> Result<(), V::Error> {
11800 let _handle = handle;
11801 match view_param {
11802 InlineCodeView::DelimCode(item) => {
11803 self.visit_delim_code_handle(item, tree)?;
11804 }
11805 InlineCodeView::InlineCode1(item) => {
11806 self.visit_inline_code_1_handle(item, tree)?;
11807 }
11808 }
11809 Ok(())
11810 }
11811 fn visit_inline_code_1_super(
11812 &mut self,
11813 handle: InlineCode1Handle,
11814 view_param: InlineCode1View,
11815 tree: &F,
11816 ) -> Result<(), V::Error> {
11817 let _handle = handle;
11818 let InlineCode1View { inline_code_1 } = view_param;
11819 let data = match inline_code_1.get_data(tree) {
11820 Ok(data) => data,
11821 Err(error) => {
11822 return self.then_construct_error(
11823 None,
11824 inline_code_1.0,
11825 NodeKind::Terminal(inline_code_1.kind()),
11826 error,
11827 tree,
11828 );
11829 }
11830 };
11831 self.visit_inline_code_1_terminal(inline_code_1, data, tree)?;
11832 Ok(())
11833 }
11834 fn visit_integer_super(
11835 &mut self,
11836 handle: IntegerHandle,
11837 view_param: IntegerView,
11838 tree: &F,
11839 ) -> Result<(), V::Error> {
11840 let _handle = handle;
11841 let IntegerView { integer } = view_param;
11842 let data = match integer.get_data(tree) {
11843 Ok(data) => data,
11844 Err(error) => {
11845 return self.then_construct_error(
11846 None,
11847 integer.0,
11848 NodeKind::Terminal(integer.kind()),
11849 error,
11850 tree,
11851 );
11852 }
11853 };
11854 self.visit_integer_terminal(integer, data, tree)?;
11855 Ok(())
11856 }
11857 fn visit_key_super(
11858 &mut self,
11859 handle: KeyHandle,
11860 view_param: KeyView,
11861 tree: &F,
11862 ) -> Result<(), V::Error> {
11863 let _handle = handle;
11864 match view_param {
11865 KeyView::KeyIdent(item) => {
11866 self.visit_key_ident_handle(item, tree)?;
11867 }
11868 KeyView::ExtensionNameSpace(item) => {
11869 self.visit_extension_name_space_handle(item, tree)?;
11870 }
11871 KeyView::String(item) => {
11872 self.visit_string_handle(item, tree)?;
11873 }
11874 KeyView::Integer(item) => {
11875 self.visit_integer_handle(item, tree)?;
11876 }
11877 KeyView::Float(item) => {
11878 self.visit_float_handle(item, tree)?;
11879 }
11880 KeyView::KeyTuple(item) => {
11881 self.visit_key_tuple_handle(item, tree)?;
11882 }
11883 KeyView::TupleIndex(item) => {
11884 self.visit_tuple_index_handle(item, tree)?;
11885 }
11886 }
11887 Ok(())
11888 }
11889 fn visit_key_ident_super(
11890 &mut self,
11891 handle: KeyIdentHandle,
11892 view_param: KeyIdentView,
11893 tree: &F,
11894 ) -> Result<(), V::Error> {
11895 let _handle = handle;
11896 match view_param {
11897 KeyIdentView::Ident(item) => {
11898 self.visit_ident_handle(item, tree)?;
11899 }
11900 KeyIdentView::True(item) => {
11901 self.visit_true_handle(item, tree)?;
11902 }
11903 KeyIdentView::False(item) => {
11904 self.visit_false_handle(item, tree)?;
11905 }
11906 KeyIdentView::Null(item) => {
11907 self.visit_null_handle(item, tree)?;
11908 }
11909 }
11910 Ok(())
11911 }
11912 fn visit_key_tail_super(
11913 &mut self,
11914 handle: KeyTailHandle,
11915 view_param: KeyTailView,
11916 tree: &F,
11917 ) -> Result<(), V::Error> {
11918 let _handle = handle;
11919 match view_param {
11920 KeyTailView::DotKey(item) => {
11921 self.visit_dot_key_handle(item, tree)?;
11922 }
11923 KeyTailView::ArrayMarker(item) => {
11924 self.visit_array_marker_handle(item, tree)?;
11925 }
11926 }
11927 Ok(())
11928 }
11929 fn visit_key_tuple_super(
11930 &mut self,
11931 handle: KeyTupleHandle,
11932 view_param: KeyTupleView,
11933 tree: &F,
11934 ) -> Result<(), V::Error> {
11935 let _handle = handle;
11936 let KeyTupleView {
11937 l_paren,
11938 key_tuple_opt,
11939 r_paren,
11940 } = view_param;
11941 self.visit_l_paren_handle(l_paren, tree)?;
11942 self.visit_key_tuple_opt_handle(key_tuple_opt, tree)?;
11943 self.visit_r_paren_handle(r_paren, tree)?;
11944 Ok(())
11945 }
11946 fn visit_key_tuple_elements_super(
11947 &mut self,
11948 handle: KeyTupleElementsHandle,
11949 view_param: KeyTupleElementsView,
11950 tree: &F,
11951 ) -> Result<(), V::Error> {
11952 let _handle = handle;
11953 let KeyTupleElementsView {
11954 key_value,
11955 key_tuple_elements_opt,
11956 } = view_param;
11957 self.visit_key_value_handle(key_value, tree)?;
11958 self.visit_key_tuple_elements_opt_handle(key_tuple_elements_opt, tree)?;
11959 Ok(())
11960 }
11961 fn visit_key_tuple_elements_opt_super(
11962 &mut self,
11963 handle: KeyTupleElementsOptHandle,
11964 view_param: KeyTupleElementsTailHandle,
11965 tree: &F,
11966 ) -> Result<(), V::Error> {
11967 let _handle = handle;
11968 self.visit_key_tuple_elements_tail_handle(view_param, tree)?;
11969 Ok(())
11970 }
11971 fn visit_key_tuple_elements_tail_super(
11972 &mut self,
11973 handle: KeyTupleElementsTailHandle,
11974 view_param: KeyTupleElementsTailView,
11975 tree: &F,
11976 ) -> Result<(), V::Error> {
11977 let _handle = handle;
11978 let KeyTupleElementsTailView {
11979 comma,
11980 key_tuple_elements_tail_opt,
11981 } = view_param;
11982 self.visit_comma_handle(comma, tree)?;
11983 self.visit_key_tuple_elements_tail_opt_handle(key_tuple_elements_tail_opt, tree)?;
11984 Ok(())
11985 }
11986 fn visit_key_tuple_elements_tail_opt_super(
11987 &mut self,
11988 handle: KeyTupleElementsTailOptHandle,
11989 view_param: KeyTupleElementsHandle,
11990 tree: &F,
11991 ) -> Result<(), V::Error> {
11992 let _handle = handle;
11993 self.visit_key_tuple_elements_handle(view_param, tree)?;
11994 Ok(())
11995 }
11996 fn visit_key_tuple_opt_super(
11997 &mut self,
11998 handle: KeyTupleOptHandle,
11999 view_param: KeyTupleElementsHandle,
12000 tree: &F,
12001 ) -> Result<(), V::Error> {
12002 let _handle = handle;
12003 self.visit_key_tuple_elements_handle(view_param, tree)?;
12004 Ok(())
12005 }
12006 fn visit_key_value_super(
12007 &mut self,
12008 handle: KeyValueHandle,
12009 view_param: KeyValueView,
12010 tree: &F,
12011 ) -> Result<(), V::Error> {
12012 let _handle = handle;
12013 match view_param {
12014 KeyValueView::Integer(item) => {
12015 self.visit_integer_handle(item, tree)?;
12016 }
12017 KeyValueView::Boolean(item) => {
12018 self.visit_boolean_handle(item, tree)?;
12019 }
12020 KeyValueView::Str(item) => {
12021 self.visit_str_handle(item, tree)?;
12022 }
12023 KeyValueView::KeyTuple(item) => {
12024 self.visit_key_tuple_handle(item, tree)?;
12025 }
12026 }
12027 Ok(())
12028 }
12029 fn visit_keys_super(
12030 &mut self,
12031 handle: KeysHandle,
12032 view_param: KeysView,
12033 tree: &F,
12034 ) -> Result<(), V::Error> {
12035 let _handle = handle;
12036 let KeysView {
12037 first_key,
12038 keys_list,
12039 } = view_param;
12040 self.visit_first_key_handle(first_key, tree)?;
12041 self.visit_keys_list_handle(keys_list, tree)?;
12042 Ok(())
12043 }
12044 fn visit_keys_list_super(
12045 &mut self,
12046 handle: KeysListHandle,
12047 view_param: KeysListView,
12048 tree: &F,
12049 ) -> Result<(), V::Error> {
12050 let _handle = handle;
12051 let KeysListView {
12052 key_tail,
12053 keys_list,
12054 } = view_param;
12055 self.visit_key_tail_handle(key_tail, tree)?;
12056 self.visit_keys_list_handle(keys_list, tree)?;
12057 Ok(())
12058 }
12059 fn visit_l_paren_super(
12060 &mut self,
12061 handle: LParenHandle,
12062 view_param: LParenView,
12063 tree: &F,
12064 ) -> Result<(), V::Error> {
12065 let _handle = handle;
12066 let LParenView { l_paren } = view_param;
12067 let data = match l_paren.get_data(tree) {
12068 Ok(data) => data,
12069 Err(error) => {
12070 return self.then_construct_error(
12071 None,
12072 l_paren.0,
12073 NodeKind::Terminal(l_paren.kind()),
12074 error,
12075 tree,
12076 );
12077 }
12078 };
12079 self.visit_l_paren_terminal(l_paren, data, tree)?;
12080 Ok(())
12081 }
12082 fn visit_lit_str_super(
12083 &mut self,
12084 handle: LitStrHandle,
12085 view_param: LitStrView,
12086 tree: &F,
12087 ) -> Result<(), V::Error> {
12088 let _handle = handle;
12089 let LitStrView { lit_str } = view_param;
12090 let data = match lit_str.get_data(tree) {
12091 Ok(data) => data,
12092 Err(error) => {
12093 return self.then_construct_error(
12094 None,
12095 lit_str.0,
12096 NodeKind::Terminal(lit_str.kind()),
12097 error,
12098 tree,
12099 );
12100 }
12101 };
12102 self.visit_lit_str_terminal(lit_str, data, tree)?;
12103 Ok(())
12104 }
12105 fn visit_lit_str_1_super(
12106 &mut self,
12107 handle: LitStr1Handle,
12108 view_param: LitStr1View,
12109 tree: &F,
12110 ) -> Result<(), V::Error> {
12111 let _handle = handle;
12112 let LitStr1View {
12113 lit_str_1_start,
12114 lit_str_1_list,
12115 lit_str_1_end,
12116 } = view_param;
12117 self.visit_lit_str_1_start_handle(lit_str_1_start, tree)?;
12118 self.visit_lit_str_1_list_handle(lit_str_1_list, tree)?;
12119 self.visit_lit_str_1_end_handle(lit_str_1_end, tree)?;
12120 Ok(())
12121 }
12122 fn visit_lit_str_1_end_super(
12123 &mut self,
12124 handle: LitStr1EndHandle,
12125 view_param: LitStr1EndView,
12126 tree: &F,
12127 ) -> Result<(), V::Error> {
12128 let _handle = handle;
12129 let LitStr1EndView { lit_str_1_end } = view_param;
12130 let data = match lit_str_1_end.get_data(tree) {
12131 Ok(data) => data,
12132 Err(error) => {
12133 return self.then_construct_error(
12134 None,
12135 lit_str_1_end.0,
12136 NodeKind::Terminal(lit_str_1_end.kind()),
12137 error,
12138 tree,
12139 );
12140 }
12141 };
12142 self.visit_lit_str_1_end_terminal(lit_str_1_end, data, tree)?;
12143 Ok(())
12144 }
12145 fn visit_lit_str_1_list_super(
12146 &mut self,
12147 handle: LitStr1ListHandle,
12148 view_param: LitStr1ListView,
12149 tree: &F,
12150 ) -> Result<(), V::Error> {
12151 let _handle = handle;
12152 let LitStr1ListView {
12153 lit_str_1_list_group,
12154 lit_str_1_list,
12155 } = view_param;
12156 self.visit_lit_str_1_list_group_handle(lit_str_1_list_group, tree)?;
12157 self.visit_lit_str_1_list_handle(lit_str_1_list, tree)?;
12158 Ok(())
12159 }
12160 fn visit_lit_str_1_list_group_super(
12161 &mut self,
12162 handle: LitStr1ListGroupHandle,
12163 view_param: LitStr1ListGroupView,
12164 tree: &F,
12165 ) -> Result<(), V::Error> {
12166 let _handle = handle;
12167 match view_param {
12168 LitStr1ListGroupView::NoSQuote(item) => {
12169 self.visit_no_s_quote_handle(item, tree)?;
12170 }
12171 LitStr1ListGroupView::SQuote(item) => {
12172 self.visit_s_quote_handle(item, tree)?;
12173 }
12174 }
12175 Ok(())
12176 }
12177 fn visit_lit_str_1_start_super(
12178 &mut self,
12179 handle: LitStr1StartHandle,
12180 view_param: LitStr1StartView,
12181 tree: &F,
12182 ) -> Result<(), V::Error> {
12183 let _handle = handle;
12184 let LitStr1StartView { lit_str_1_start } = view_param;
12185 let data = match lit_str_1_start.get_data(tree) {
12186 Ok(data) => data,
12187 Err(error) => {
12188 return self.then_construct_error(
12189 None,
12190 lit_str_1_start.0,
12191 NodeKind::Terminal(lit_str_1_start.kind()),
12192 error,
12193 tree,
12194 );
12195 }
12196 };
12197 self.visit_lit_str_1_start_terminal(lit_str_1_start, data, tree)?;
12198 Ok(())
12199 }
12200 fn visit_lit_str_2_super(
12201 &mut self,
12202 handle: LitStr2Handle,
12203 view_param: LitStr2View,
12204 tree: &F,
12205 ) -> Result<(), V::Error> {
12206 let _handle = handle;
12207 let LitStr2View {
12208 lit_str_2_start,
12209 lit_str_2_list,
12210 lit_str_2_end,
12211 } = view_param;
12212 self.visit_lit_str_2_start_handle(lit_str_2_start, tree)?;
12213 self.visit_lit_str_2_list_handle(lit_str_2_list, tree)?;
12214 self.visit_lit_str_2_end_handle(lit_str_2_end, tree)?;
12215 Ok(())
12216 }
12217 fn visit_lit_str_2_end_super(
12218 &mut self,
12219 handle: LitStr2EndHandle,
12220 view_param: LitStr2EndView,
12221 tree: &F,
12222 ) -> Result<(), V::Error> {
12223 let _handle = handle;
12224 let LitStr2EndView { lit_str_2_end } = view_param;
12225 let data = match lit_str_2_end.get_data(tree) {
12226 Ok(data) => data,
12227 Err(error) => {
12228 return self.then_construct_error(
12229 None,
12230 lit_str_2_end.0,
12231 NodeKind::Terminal(lit_str_2_end.kind()),
12232 error,
12233 tree,
12234 );
12235 }
12236 };
12237 self.visit_lit_str_2_end_terminal(lit_str_2_end, data, tree)?;
12238 Ok(())
12239 }
12240 fn visit_lit_str_2_list_super(
12241 &mut self,
12242 handle: LitStr2ListHandle,
12243 view_param: LitStr2ListView,
12244 tree: &F,
12245 ) -> Result<(), V::Error> {
12246 let _handle = handle;
12247 let LitStr2ListView {
12248 lit_str_2_list_group,
12249 lit_str_2_list,
12250 } = view_param;
12251 self.visit_lit_str_2_list_group_handle(lit_str_2_list_group, tree)?;
12252 self.visit_lit_str_2_list_handle(lit_str_2_list, tree)?;
12253 Ok(())
12254 }
12255 fn visit_lit_str_2_list_group_super(
12256 &mut self,
12257 handle: LitStr2ListGroupHandle,
12258 view_param: LitStr2ListGroupView,
12259 tree: &F,
12260 ) -> Result<(), V::Error> {
12261 let _handle = handle;
12262 match view_param {
12263 LitStr2ListGroupView::NoSQuote(item) => {
12264 self.visit_no_s_quote_handle(item, tree)?;
12265 }
12266 LitStr2ListGroupView::SQuote(item) => {
12267 self.visit_s_quote_handle(item, tree)?;
12268 }
12269 }
12270 Ok(())
12271 }
12272 fn visit_lit_str_2_start_super(
12273 &mut self,
12274 handle: LitStr2StartHandle,
12275 view_param: LitStr2StartView,
12276 tree: &F,
12277 ) -> Result<(), V::Error> {
12278 let _handle = handle;
12279 let LitStr2StartView { lit_str_2_start } = view_param;
12280 let data = match lit_str_2_start.get_data(tree) {
12281 Ok(data) => data,
12282 Err(error) => {
12283 return self.then_construct_error(
12284 None,
12285 lit_str_2_start.0,
12286 NodeKind::Terminal(lit_str_2_start.kind()),
12287 error,
12288 tree,
12289 );
12290 }
12291 };
12292 self.visit_lit_str_2_start_terminal(lit_str_2_start, data, tree)?;
12293 Ok(())
12294 }
12295 fn visit_lit_str_3_super(
12296 &mut self,
12297 handle: LitStr3Handle,
12298 view_param: LitStr3View,
12299 tree: &F,
12300 ) -> Result<(), V::Error> {
12301 let _handle = handle;
12302 let LitStr3View {
12303 lit_str_3_start,
12304 lit_str_3_list,
12305 lit_str_3_end,
12306 } = view_param;
12307 self.visit_lit_str_3_start_handle(lit_str_3_start, tree)?;
12308 self.visit_lit_str_3_list_handle(lit_str_3_list, tree)?;
12309 self.visit_lit_str_3_end_handle(lit_str_3_end, tree)?;
12310 Ok(())
12311 }
12312 fn visit_lit_str_3_end_super(
12313 &mut self,
12314 handle: LitStr3EndHandle,
12315 view_param: LitStr3EndView,
12316 tree: &F,
12317 ) -> Result<(), V::Error> {
12318 let _handle = handle;
12319 let LitStr3EndView { lit_str_3_end } = view_param;
12320 let data = match lit_str_3_end.get_data(tree) {
12321 Ok(data) => data,
12322 Err(error) => {
12323 return self.then_construct_error(
12324 None,
12325 lit_str_3_end.0,
12326 NodeKind::Terminal(lit_str_3_end.kind()),
12327 error,
12328 tree,
12329 );
12330 }
12331 };
12332 self.visit_lit_str_3_end_terminal(lit_str_3_end, data, tree)?;
12333 Ok(())
12334 }
12335 fn visit_lit_str_3_list_super(
12336 &mut self,
12337 handle: LitStr3ListHandle,
12338 view_param: LitStr3ListView,
12339 tree: &F,
12340 ) -> Result<(), V::Error> {
12341 let _handle = handle;
12342 let LitStr3ListView {
12343 lit_str_3_list_group,
12344 lit_str_3_list,
12345 } = view_param;
12346 self.visit_lit_str_3_list_group_handle(lit_str_3_list_group, tree)?;
12347 self.visit_lit_str_3_list_handle(lit_str_3_list, tree)?;
12348 Ok(())
12349 }
12350 fn visit_lit_str_3_list_group_super(
12351 &mut self,
12352 handle: LitStr3ListGroupHandle,
12353 view_param: LitStr3ListGroupView,
12354 tree: &F,
12355 ) -> Result<(), V::Error> {
12356 let _handle = handle;
12357 match view_param {
12358 LitStr3ListGroupView::NoSQuote(item) => {
12359 self.visit_no_s_quote_handle(item, tree)?;
12360 }
12361 LitStr3ListGroupView::SQuote(item) => {
12362 self.visit_s_quote_handle(item, tree)?;
12363 }
12364 }
12365 Ok(())
12366 }
12367 fn visit_lit_str_3_start_super(
12368 &mut self,
12369 handle: LitStr3StartHandle,
12370 view_param: LitStr3StartView,
12371 tree: &F,
12372 ) -> Result<(), V::Error> {
12373 let _handle = handle;
12374 let LitStr3StartView { lit_str_3_start } = view_param;
12375 let data = match lit_str_3_start.get_data(tree) {
12376 Ok(data) => data,
12377 Err(error) => {
12378 return self.then_construct_error(
12379 None,
12380 lit_str_3_start.0,
12381 NodeKind::Terminal(lit_str_3_start.kind()),
12382 error,
12383 tree,
12384 );
12385 }
12386 };
12387 self.visit_lit_str_3_start_terminal(lit_str_3_start, data, tree)?;
12388 Ok(())
12389 }
12390 fn visit_map_bind_super(
12391 &mut self,
12392 handle: MapBindHandle,
12393 view_param: MapBindView,
12394 tree: &F,
12395 ) -> Result<(), V::Error> {
12396 let _handle = handle;
12397 let MapBindView { map_bind } = view_param;
12398 let data = match map_bind.get_data(tree) {
12399 Ok(data) => data,
12400 Err(error) => {
12401 return self.then_construct_error(
12402 None,
12403 map_bind.0,
12404 NodeKind::Terminal(map_bind.kind()),
12405 error,
12406 tree,
12407 );
12408 }
12409 };
12410 self.visit_map_bind_terminal(map_bind, data, tree)?;
12411 Ok(())
12412 }
12413 fn visit_na_n_super(
12414 &mut self,
12415 handle: NaNHandle,
12416 view_param: NaNView,
12417 tree: &F,
12418 ) -> Result<(), V::Error> {
12419 let _handle = handle;
12420 let NaNView { na_n } = view_param;
12421 let data = match na_n.get_data(tree) {
12422 Ok(data) => data,
12423 Err(error) => {
12424 return self.then_construct_error(
12425 None,
12426 na_n.0,
12427 NodeKind::Terminal(na_n.kind()),
12428 error,
12429 tree,
12430 );
12431 }
12432 };
12433 self.visit_na_n_terminal(na_n, data, tree)?;
12434 Ok(())
12435 }
12436 fn visit_newline_bind_super(
12437 &mut self,
12438 handle: NewlineBindHandle,
12439 view_param: NewlineBindView,
12440 tree: &F,
12441 ) -> Result<(), V::Error> {
12442 let _handle = handle;
12443 let NewlineBindView { newline_bind } = view_param;
12444 let data = match newline_bind.get_data(tree) {
12445 Ok(data) => data,
12446 Err(error) => {
12447 return self.then_construct_error(
12448 None,
12449 newline_bind.0,
12450 NodeKind::Terminal(newline_bind.kind()),
12451 error,
12452 tree,
12453 );
12454 }
12455 };
12456 self.visit_newline_bind_terminal(newline_bind, data, tree)?;
12457 Ok(())
12458 }
12459 fn visit_newline_head_super(
12460 &mut self,
12461 handle: NewlineHeadHandle,
12462 view_param: NewlineHeadView,
12463 tree: &F,
12464 ) -> Result<(), V::Error> {
12465 let _handle = handle;
12466 let NewlineHeadView {
12467 grammar_newline,
12468 newline_head_opt,
12469 } = view_param;
12470 self.visit_grammar_newline_handle(grammar_newline, tree)?;
12471 self.visit_newline_head_opt_handle(newline_head_opt, tree)?;
12472 Ok(())
12473 }
12474 fn visit_newline_head_opt_super(
12475 &mut self,
12476 handle: NewlineHeadOptHandle,
12477 view_param: FlatRootBindingHandle,
12478 tree: &F,
12479 ) -> Result<(), V::Error> {
12480 let _handle = handle;
12481 self.visit_flat_root_binding_handle(view_param, tree)?;
12482 Ok(())
12483 }
12484 fn visit_newline_text_start_super(
12485 &mut self,
12486 handle: NewlineTextStartHandle,
12487 view_param: NewlineTextStartView,
12488 tree: &F,
12489 ) -> Result<(), V::Error> {
12490 let _handle = handle;
12491 let NewlineTextStartView { newline_text_start } = view_param;
12492 let data = match newline_text_start.get_data(tree) {
12493 Ok(data) => data,
12494 Err(error) => {
12495 return self.then_construct_error(
12496 None,
12497 newline_text_start.0,
12498 NodeKind::Terminal(newline_text_start.kind()),
12499 error,
12500 tree,
12501 );
12502 }
12503 };
12504 self.visit_newline_text_start_terminal(newline_text_start, data, tree)?;
12505 Ok(())
12506 }
12507 fn visit_no_backtick_super(
12508 &mut self,
12509 handle: NoBacktickHandle,
12510 view_param: NoBacktickView,
12511 tree: &F,
12512 ) -> Result<(), V::Error> {
12513 let _handle = handle;
12514 let NoBacktickView { no_backtick } = view_param;
12515 let data = match no_backtick.get_data(tree) {
12516 Ok(data) => data,
12517 Err(error) => {
12518 return self.then_construct_error(
12519 None,
12520 no_backtick.0,
12521 NodeKind::Terminal(no_backtick.kind()),
12522 error,
12523 tree,
12524 );
12525 }
12526 };
12527 self.visit_no_backtick_terminal(no_backtick, data, tree)?;
12528 Ok(())
12529 }
12530 fn visit_no_s_quote_super(
12531 &mut self,
12532 handle: NoSQuoteHandle,
12533 view_param: NoSQuoteView,
12534 tree: &F,
12535 ) -> Result<(), V::Error> {
12536 let _handle = handle;
12537 let NoSQuoteView { no_s_quote } = view_param;
12538 let data = match no_s_quote.get_data(tree) {
12539 Ok(data) => data,
12540 Err(error) => {
12541 return self.then_construct_error(
12542 None,
12543 no_s_quote.0,
12544 NodeKind::Terminal(no_s_quote.kind()),
12545 error,
12546 tree,
12547 );
12548 }
12549 };
12550 self.visit_no_s_quote_terminal(no_s_quote, data, tree)?;
12551 Ok(())
12552 }
12553 fn visit_null_super(
12554 &mut self,
12555 handle: NullHandle,
12556 view_param: NullView,
12557 tree: &F,
12558 ) -> Result<(), V::Error> {
12559 let _handle = handle;
12560 let NullView { null } = view_param;
12561 let data = match null.get_data(tree) {
12562 Ok(data) => data,
12563 Err(error) => {
12564 return self.then_construct_error(
12565 None,
12566 null.0,
12567 NodeKind::Terminal(null.kind()),
12568 error,
12569 tree,
12570 );
12571 }
12572 };
12573 self.visit_null_terminal(null, data, tree)?;
12574 Ok(())
12575 }
12576 fn visit_number_super(
12577 &mut self,
12578 handle: NumberHandle,
12579 view_param: NumberView,
12580 tree: &F,
12581 ) -> Result<(), V::Error> {
12582 let _handle = handle;
12583 match view_param {
12584 NumberView::Float(item) => {
12585 self.visit_float_handle(item, tree)?;
12586 }
12587 NumberView::Integer(item) => {
12588 self.visit_integer_handle(item, tree)?;
12589 }
12590 NumberView::Inf(item) => {
12591 self.visit_inf_handle(item, tree)?;
12592 }
12593 NumberView::NaN(item) => {
12594 self.visit_na_n_handle(item, tree)?;
12595 }
12596 }
12597 Ok(())
12598 }
12599 fn visit_object_super(
12600 &mut self,
12601 handle: ObjectHandle,
12602 view_param: ObjectView,
12603 tree: &F,
12604 ) -> Result<(), V::Error> {
12605 let _handle = handle;
12606 let ObjectView {
12607 begin,
12608 object_opt,
12609 object_list,
12610 end,
12611 } = view_param;
12612 self.visit_begin_handle(begin, tree)?;
12613 self.visit_object_opt_handle(object_opt, tree)?;
12614 self.visit_object_list_handle(object_list, tree)?;
12615 self.visit_end_handle(end, tree)?;
12616 Ok(())
12617 }
12618 fn visit_object_list_super(
12619 &mut self,
12620 handle: ObjectListHandle,
12621 view_param: ObjectListView,
12622 tree: &F,
12623 ) -> Result<(), V::Error> {
12624 let _handle = handle;
12625 let ObjectListView {
12626 keys,
12627 map_bind,
12628 value,
12629 object_opt_0,
12630 object_list,
12631 } = view_param;
12632 self.visit_keys_handle(keys, tree)?;
12633 self.visit_map_bind_handle(map_bind, tree)?;
12634 self.visit_value_handle(value, tree)?;
12635 self.visit_object_opt_0_handle(object_opt_0, tree)?;
12636 self.visit_object_list_handle(object_list, tree)?;
12637 Ok(())
12638 }
12639 fn visit_object_opt_super(
12640 &mut self,
12641 handle: ObjectOptHandle,
12642 view_param: ObjectOptView,
12643 tree: &F,
12644 ) -> Result<(), V::Error> {
12645 let _handle = handle;
12646 let ObjectOptView {
12647 value_binding,
12648 object_opt_1,
12649 } = view_param;
12650 self.visit_value_binding_handle(value_binding, tree)?;
12651 self.visit_object_opt_1_handle(object_opt_1, tree)?;
12652 Ok(())
12653 }
12654 fn visit_object_opt_0_super(
12655 &mut self,
12656 handle: ObjectOpt0Handle,
12657 view_param: CommaHandle,
12658 tree: &F,
12659 ) -> Result<(), V::Error> {
12660 let _handle = handle;
12661 self.visit_comma_handle(view_param, tree)?;
12662 Ok(())
12663 }
12664 fn visit_object_opt_1_super(
12665 &mut self,
12666 handle: ObjectOpt1Handle,
12667 view_param: CommaHandle,
12668 tree: &F,
12669 ) -> Result<(), V::Error> {
12670 let _handle = handle;
12671 self.visit_comma_handle(view_param, tree)?;
12672 Ok(())
12673 }
12674 fn visit_r_paren_super(
12675 &mut self,
12676 handle: RParenHandle,
12677 view_param: RParenView,
12678 tree: &F,
12679 ) -> Result<(), V::Error> {
12680 let _handle = handle;
12681 let RParenView { r_paren } = view_param;
12682 let data = match r_paren.get_data(tree) {
12683 Ok(data) => data,
12684 Err(error) => {
12685 return self.then_construct_error(
12686 None,
12687 r_paren.0,
12688 NodeKind::Terminal(r_paren.kind()),
12689 error,
12690 tree,
12691 );
12692 }
12693 };
12694 self.visit_r_paren_terminal(r_paren, data, tree)?;
12695 Ok(())
12696 }
12697 fn visit_root_binding_super(
12698 &mut self,
12699 handle: RootBindingHandle,
12700 view_param: RootBindingView,
12701 tree: &F,
12702 ) -> Result<(), V::Error> {
12703 let _handle = handle;
12704 match view_param {
12705 RootBindingView::RootValueBinding(item) => {
12706 self.visit_root_value_binding_handle(item, tree)?;
12707 }
12708 RootBindingView::RootTextBinding(item) => {
12709 self.visit_root_text_binding_handle(item, tree)?;
12710 }
12711 }
12712 Ok(())
12713 }
12714 fn visit_root_text_binding_super(
12715 &mut self,
12716 handle: RootTextBindingHandle,
12717 view_param: RootTextBindingView,
12718 tree: &F,
12719 ) -> Result<(), V::Error> {
12720 let _handle = handle;
12721 let RootTextBindingView {
12722 newline_text_start,
12723 root_text_binding_opt,
12724 root_text_binding_opt_0,
12725 root_text_binding_opt_1,
12726 } = view_param;
12727 self.visit_newline_text_start_handle(newline_text_start, tree)?;
12728 self.visit_root_text_binding_opt_handle(root_text_binding_opt, tree)?;
12729 self.visit_root_text_binding_opt_0_handle(root_text_binding_opt_0, tree)?;
12730 self.visit_root_text_binding_opt_1_handle(root_text_binding_opt_1, tree)?;
12731 Ok(())
12732 }
12733 fn visit_root_text_binding_opt_super(
12734 &mut self,
12735 handle: RootTextBindingOptHandle,
12736 view_param: WsHandle,
12737 tree: &F,
12738 ) -> Result<(), V::Error> {
12739 let _handle = handle;
12740 self.visit_ws_handle(view_param, tree)?;
12741 Ok(())
12742 }
12743 fn visit_root_text_binding_opt_0_super(
12744 &mut self,
12745 handle: RootTextBindingOpt0Handle,
12746 view_param: TextHandle,
12747 tree: &F,
12748 ) -> Result<(), V::Error> {
12749 let _handle = handle;
12750 self.visit_text_handle(view_param, tree)?;
12751 Ok(())
12752 }
12753 fn visit_root_text_binding_opt_1_super(
12754 &mut self,
12755 handle: RootTextBindingOpt1Handle,
12756 view_param: GrammarNewlineHandle,
12757 tree: &F,
12758 ) -> Result<(), V::Error> {
12759 let _handle = handle;
12760 self.visit_grammar_newline_handle(view_param, tree)?;
12761 Ok(())
12762 }
12763 fn visit_root_value_binding_super(
12764 &mut self,
12765 handle: RootValueBindingHandle,
12766 view_param: RootValueBindingView,
12767 tree: &F,
12768 ) -> Result<(), V::Error> {
12769 let _handle = handle;
12770 let RootValueBindingView {
12771 newline_bind,
12772 value,
12773 } = view_param;
12774 self.visit_newline_bind_handle(newline_bind, tree)?;
12775 self.visit_value_handle(value, tree)?;
12776 Ok(())
12777 }
12778 fn visit_s_quote_super(
12779 &mut self,
12780 handle: SQuoteHandle,
12781 view_param: SQuoteView,
12782 tree: &F,
12783 ) -> Result<(), V::Error> {
12784 let _handle = handle;
12785 let SQuoteView { s_quote } = view_param;
12786 let data = match s_quote.get_data(tree) {
12787 Ok(data) => data,
12788 Err(error) => {
12789 return self.then_construct_error(
12790 None,
12791 s_quote.0,
12792 NodeKind::Terminal(s_quote.kind()),
12793 error,
12794 tree,
12795 );
12796 }
12797 };
12798 self.visit_s_quote_terminal(s_quote, data, tree)?;
12799 Ok(())
12800 }
12801 fn visit_section_super(
12802 &mut self,
12803 handle: SectionHandle,
12804 view_param: SectionView,
12805 tree: &F,
12806 ) -> Result<(), V::Error> {
12807 let _handle = handle;
12808 let SectionView {
12809 at,
12810 keys,
12811 section_body,
12812 } = view_param;
12813 self.visit_at_handle(at, tree)?;
12814 self.visit_keys_handle(keys, tree)?;
12815 self.visit_section_body_handle(section_body, tree)?;
12816 Ok(())
12817 }
12818 fn visit_section_binding_super(
12819 &mut self,
12820 handle: SectionBindingHandle,
12821 view_param: SectionBindingView,
12822 tree: &F,
12823 ) -> Result<(), V::Error> {
12824 let _handle = handle;
12825 let SectionBindingView { begin, eure, end } = view_param;
12826 self.visit_begin_handle(begin, tree)?;
12827 self.visit_eure_handle(eure, tree)?;
12828 self.visit_end_handle(end, tree)?;
12829 Ok(())
12830 }
12831 fn visit_section_body_super(
12832 &mut self,
12833 handle: SectionBodyHandle,
12834 view_param: SectionBodyView,
12835 tree: &F,
12836 ) -> Result<(), V::Error> {
12837 let _handle = handle;
12838 match view_param {
12839 SectionBodyView::SectionBodyOpt(item) => {
12840 self.visit_section_body_opt_handle(item, tree)?;
12841 }
12842 SectionBodyView::BlockBody(item) => {
12843 self.visit_block_body_handle(item, tree)?;
12844 }
12845 }
12846 Ok(())
12847 }
12848 fn visit_section_body_opt_super(
12849 &mut self,
12850 handle: SectionBodyOptHandle,
12851 view_param: FlatBodyHandle,
12852 tree: &F,
12853 ) -> Result<(), V::Error> {
12854 let _handle = handle;
12855 self.visit_flat_body_handle(view_param, tree)?;
12856 Ok(())
12857 }
12858 fn visit_section_head_super(
12859 &mut self,
12860 handle: SectionHeadHandle,
12861 view_param: SectionHeadView,
12862 tree: &F,
12863 ) -> Result<(), V::Error> {
12864 let _handle = handle;
12865 match view_param {
12866 SectionHeadView::RootBinding(item) => {
12867 self.visit_root_binding_handle(item, tree)?;
12868 }
12869 SectionHeadView::NewlineHead(item) => {
12870 self.visit_newline_head_handle(item, tree)?;
12871 }
12872 }
12873 Ok(())
12874 }
12875 fn visit_str_super(
12876 &mut self,
12877 handle: StrHandle,
12878 view_param: StrView,
12879 tree: &F,
12880 ) -> Result<(), V::Error> {
12881 let _handle = handle;
12882 let StrView { str } = view_param;
12883 let data = match str.get_data(tree) {
12884 Ok(data) => data,
12885 Err(error) => {
12886 return self.then_construct_error(
12887 None,
12888 str.0,
12889 NodeKind::Terminal(str.kind()),
12890 error,
12891 tree,
12892 );
12893 }
12894 };
12895 self.visit_str_terminal(str, data, tree)?;
12896 Ok(())
12897 }
12898 fn visit_string_super(
12899 &mut self,
12900 handle: StringHandle,
12901 view_param: StringView,
12902 tree: &F,
12903 ) -> Result<(), V::Error> {
12904 let _handle = handle;
12905 match view_param {
12906 StringView::Str(item) => {
12907 self.visit_str_handle(item, tree)?;
12908 }
12909 StringView::LitStr(item) => {
12910 self.visit_lit_str_handle(item, tree)?;
12911 }
12912 StringView::LitStr1(item) => {
12913 self.visit_lit_str_1_handle(item, tree)?;
12914 }
12915 StringView::LitStr2(item) => {
12916 self.visit_lit_str_2_handle(item, tree)?;
12917 }
12918 StringView::LitStr3(item) => {
12919 self.visit_lit_str_3_handle(item, tree)?;
12920 }
12921 }
12922 Ok(())
12923 }
12924 fn visit_strings_super(
12925 &mut self,
12926 handle: StringsHandle,
12927 view_param: StringsView,
12928 tree: &F,
12929 ) -> Result<(), V::Error> {
12930 let _handle = handle;
12931 let StringsView {
12932 string,
12933 strings_list,
12934 } = view_param;
12935 self.visit_string_handle(string, tree)?;
12936 self.visit_strings_list_handle(strings_list, tree)?;
12937 Ok(())
12938 }
12939 fn visit_strings_list_super(
12940 &mut self,
12941 handle: StringsListHandle,
12942 view_param: StringsListView,
12943 tree: &F,
12944 ) -> Result<(), V::Error> {
12945 let _handle = handle;
12946 let StringsListView {
12947 r#continue,
12948 string,
12949 strings_list,
12950 } = view_param;
12951 self.visit_continue_handle(r#continue, tree)?;
12952 self.visit_string_handle(string, tree)?;
12953 self.visit_strings_list_handle(strings_list, tree)?;
12954 Ok(())
12955 }
12956 fn visit_text_super(
12957 &mut self,
12958 handle: TextHandle,
12959 view_param: TextView,
12960 tree: &F,
12961 ) -> Result<(), V::Error> {
12962 let _handle = handle;
12963 let TextView { text } = view_param;
12964 let data = match text.get_data(tree) {
12965 Ok(data) => data,
12966 Err(error) => {
12967 return self.then_construct_error(
12968 None,
12969 text.0,
12970 NodeKind::Terminal(text.kind()),
12971 error,
12972 tree,
12973 );
12974 }
12975 };
12976 self.visit_text_terminal(text, data, tree)?;
12977 Ok(())
12978 }
12979 fn visit_text_binding_super(
12980 &mut self,
12981 handle: TextBindingHandle,
12982 view_param: TextBindingView,
12983 tree: &F,
12984 ) -> Result<(), V::Error> {
12985 let _handle = handle;
12986 let TextBindingView {
12987 text_start,
12988 text_binding_opt,
12989 text_binding_opt_0,
12990 text_binding_opt_1,
12991 } = view_param;
12992 self.visit_text_start_handle(text_start, tree)?;
12993 self.visit_text_binding_opt_handle(text_binding_opt, tree)?;
12994 self.visit_text_binding_opt_0_handle(text_binding_opt_0, tree)?;
12995 self.visit_text_binding_opt_1_handle(text_binding_opt_1, tree)?;
12996 Ok(())
12997 }
12998 fn visit_text_binding_opt_super(
12999 &mut self,
13000 handle: TextBindingOptHandle,
13001 view_param: WsHandle,
13002 tree: &F,
13003 ) -> Result<(), V::Error> {
13004 let _handle = handle;
13005 self.visit_ws_handle(view_param, tree)?;
13006 Ok(())
13007 }
13008 fn visit_text_binding_opt_0_super(
13009 &mut self,
13010 handle: TextBindingOpt0Handle,
13011 view_param: TextHandle,
13012 tree: &F,
13013 ) -> Result<(), V::Error> {
13014 let _handle = handle;
13015 self.visit_text_handle(view_param, tree)?;
13016 Ok(())
13017 }
13018 fn visit_text_binding_opt_1_super(
13019 &mut self,
13020 handle: TextBindingOpt1Handle,
13021 view_param: GrammarNewlineHandle,
13022 tree: &F,
13023 ) -> Result<(), V::Error> {
13024 let _handle = handle;
13025 self.visit_grammar_newline_handle(view_param, tree)?;
13026 Ok(())
13027 }
13028 fn visit_text_start_super(
13029 &mut self,
13030 handle: TextStartHandle,
13031 view_param: TextStartView,
13032 tree: &F,
13033 ) -> Result<(), V::Error> {
13034 let _handle = handle;
13035 let TextStartView { text_start } = view_param;
13036 let data = match text_start.get_data(tree) {
13037 Ok(data) => data,
13038 Err(error) => {
13039 return self.then_construct_error(
13040 None,
13041 text_start.0,
13042 NodeKind::Terminal(text_start.kind()),
13043 error,
13044 tree,
13045 );
13046 }
13047 };
13048 self.visit_text_start_terminal(text_start, data, tree)?;
13049 Ok(())
13050 }
13051 fn visit_top_level_binding_super(
13052 &mut self,
13053 handle: TopLevelBindingHandle,
13054 view_param: TopLevelBindingView,
13055 tree: &F,
13056 ) -> Result<(), V::Error> {
13057 let _handle = handle;
13058 match view_param {
13059 TopLevelBindingView::ValueBinding(item) => {
13060 self.visit_value_binding_handle(item, tree)?;
13061 }
13062 TopLevelBindingView::TextBinding(item) => {
13063 self.visit_text_binding_handle(item, tree)?;
13064 }
13065 }
13066 Ok(())
13067 }
13068 fn visit_true_super(
13069 &mut self,
13070 handle: TrueHandle,
13071 view_param: TrueView,
13072 tree: &F,
13073 ) -> Result<(), V::Error> {
13074 let _handle = handle;
13075 let TrueView { r#true } = view_param;
13076 let data = match r#true.get_data(tree) {
13077 Ok(data) => data,
13078 Err(error) => {
13079 return self.then_construct_error(
13080 None,
13081 r#true.0,
13082 NodeKind::Terminal(r#true.kind()),
13083 error,
13084 tree,
13085 );
13086 }
13087 };
13088 self.visit_true_terminal(r#true, data, tree)?;
13089 Ok(())
13090 }
13091 fn visit_tuple_super(
13092 &mut self,
13093 handle: TupleHandle,
13094 view_param: TupleView,
13095 tree: &F,
13096 ) -> Result<(), V::Error> {
13097 let _handle = handle;
13098 let TupleView {
13099 l_paren,
13100 tuple_opt,
13101 r_paren,
13102 } = view_param;
13103 self.visit_l_paren_handle(l_paren, tree)?;
13104 self.visit_tuple_opt_handle(tuple_opt, tree)?;
13105 self.visit_r_paren_handle(r_paren, tree)?;
13106 Ok(())
13107 }
13108 fn visit_tuple_elements_super(
13109 &mut self,
13110 handle: TupleElementsHandle,
13111 view_param: TupleElementsView,
13112 tree: &F,
13113 ) -> Result<(), V::Error> {
13114 let _handle = handle;
13115 let TupleElementsView {
13116 value,
13117 tuple_elements_opt,
13118 } = view_param;
13119 self.visit_value_handle(value, tree)?;
13120 self.visit_tuple_elements_opt_handle(tuple_elements_opt, tree)?;
13121 Ok(())
13122 }
13123 fn visit_tuple_elements_opt_super(
13124 &mut self,
13125 handle: TupleElementsOptHandle,
13126 view_param: TupleElementsTailHandle,
13127 tree: &F,
13128 ) -> Result<(), V::Error> {
13129 let _handle = handle;
13130 self.visit_tuple_elements_tail_handle(view_param, tree)?;
13131 Ok(())
13132 }
13133 fn visit_tuple_elements_tail_super(
13134 &mut self,
13135 handle: TupleElementsTailHandle,
13136 view_param: TupleElementsTailView,
13137 tree: &F,
13138 ) -> Result<(), V::Error> {
13139 let _handle = handle;
13140 let TupleElementsTailView {
13141 comma,
13142 tuple_elements_tail_opt,
13143 } = view_param;
13144 self.visit_comma_handle(comma, tree)?;
13145 self.visit_tuple_elements_tail_opt_handle(tuple_elements_tail_opt, tree)?;
13146 Ok(())
13147 }
13148 fn visit_tuple_elements_tail_opt_super(
13149 &mut self,
13150 handle: TupleElementsTailOptHandle,
13151 view_param: TupleElementsHandle,
13152 tree: &F,
13153 ) -> Result<(), V::Error> {
13154 let _handle = handle;
13155 self.visit_tuple_elements_handle(view_param, tree)?;
13156 Ok(())
13157 }
13158 fn visit_tuple_index_super(
13159 &mut self,
13160 handle: TupleIndexHandle,
13161 view_param: TupleIndexView,
13162 tree: &F,
13163 ) -> Result<(), V::Error> {
13164 let _handle = handle;
13165 let TupleIndexView { hash, integer } = view_param;
13166 let data = match hash.get_data(tree) {
13167 Ok(data) => data,
13168 Err(error) => {
13169 return self.then_construct_error(
13170 None,
13171 hash.0,
13172 NodeKind::Terminal(hash.kind()),
13173 error,
13174 tree,
13175 );
13176 }
13177 };
13178 self.visit_hash_terminal(hash, data, tree)?;
13179 self.visit_integer_handle(integer, tree)?;
13180 Ok(())
13181 }
13182 fn visit_tuple_opt_super(
13183 &mut self,
13184 handle: TupleOptHandle,
13185 view_param: TupleElementsHandle,
13186 tree: &F,
13187 ) -> Result<(), V::Error> {
13188 let _handle = handle;
13189 self.visit_tuple_elements_handle(view_param, tree)?;
13190 Ok(())
13191 }
13192 fn visit_value_super(
13193 &mut self,
13194 handle: ValueHandle,
13195 view_param: ValueView,
13196 tree: &F,
13197 ) -> Result<(), V::Error> {
13198 let _handle = handle;
13199 match view_param {
13200 ValueView::Object(item) => {
13201 self.visit_object_handle(item, tree)?;
13202 }
13203 ValueView::Array(item) => {
13204 self.visit_array_handle(item, tree)?;
13205 }
13206 ValueView::Tuple(item) => {
13207 self.visit_tuple_handle(item, tree)?;
13208 }
13209 ValueView::Number(item) => {
13210 self.visit_number_handle(item, tree)?;
13211 }
13212 ValueView::Boolean(item) => {
13213 self.visit_boolean_handle(item, tree)?;
13214 }
13215 ValueView::Null(item) => {
13216 self.visit_null_handle(item, tree)?;
13217 }
13218 ValueView::Strings(item) => {
13219 self.visit_strings_handle(item, tree)?;
13220 }
13221 ValueView::Hole(item) => {
13222 self.visit_hole_handle(item, tree)?;
13223 }
13224 ValueView::CodeBlock(item) => {
13225 self.visit_code_block_handle(item, tree)?;
13226 }
13227 ValueView::InlineCode(item) => {
13228 self.visit_inline_code_handle(item, tree)?;
13229 }
13230 }
13231 Ok(())
13232 }
13233 fn visit_value_binding_super(
13234 &mut self,
13235 handle: ValueBindingHandle,
13236 view_param: ValueBindingView,
13237 tree: &F,
13238 ) -> Result<(), V::Error> {
13239 let _handle = handle;
13240 let ValueBindingView { bind, value } = view_param;
13241 self.visit_bind_handle(bind, tree)?;
13242 self.visit_value_handle(value, tree)?;
13243 Ok(())
13244 }
13245 fn visit_ws_super(
13246 &mut self,
13247 handle: WsHandle,
13248 view_param: WsView,
13249 tree: &F,
13250 ) -> Result<(), V::Error> {
13251 let _handle = handle;
13252 let WsView { ws } = view_param;
13253 let data = match ws.get_data(tree) {
13254 Ok(data) => data,
13255 Err(error) => {
13256 return self.then_construct_error(
13257 None,
13258 ws.0,
13259 NodeKind::Terminal(ws.kind()),
13260 error,
13261 tree,
13262 );
13263 }
13264 };
13265 self.visit_ws_terminal(ws, data, tree)?;
13266 Ok(())
13267 }
13268 fn visit_root_super(
13269 &mut self,
13270 handle: RootHandle,
13271 view_param: RootView,
13272 tree: &F,
13273 ) -> Result<(), V::Error> {
13274 let _handle = handle;
13275 let RootView { eure } = view_param;
13276 self.visit_eure_handle(eure, tree)?;
13277 Ok(())
13278 }
13279 fn visit_new_line_terminal_super(
13280 &mut self,
13281 terminal: NewLine,
13282 data: TerminalData,
13283 tree: &F,
13284 ) -> Result<(), V::Error> {
13285 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13286 Ok(())
13287 }
13288 fn visit_whitespace_terminal_super(
13289 &mut self,
13290 terminal: Whitespace,
13291 data: TerminalData,
13292 tree: &F,
13293 ) -> Result<(), V::Error> {
13294 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13295 Ok(())
13296 }
13297 fn visit_line_comment_terminal_super(
13298 &mut self,
13299 terminal: LineComment,
13300 data: TerminalData,
13301 tree: &F,
13302 ) -> Result<(), V::Error> {
13303 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13304 Ok(())
13305 }
13306 fn visit_block_comment_terminal_super(
13307 &mut self,
13308 terminal: BlockComment,
13309 data: TerminalData,
13310 tree: &F,
13311 ) -> Result<(), V::Error> {
13312 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13313 Ok(())
13314 }
13315 fn visit_hash_terminal_super(
13316 &mut self,
13317 terminal: Hash,
13318 data: TerminalData,
13319 tree: &F,
13320 ) -> Result<(), V::Error> {
13321 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13322 Ok(())
13323 }
13324 fn visit_map_bind_terminal_super(
13325 &mut self,
13326 terminal: MapBind,
13327 data: TerminalData,
13328 tree: &F,
13329 ) -> Result<(), V::Error> {
13330 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13331 Ok(())
13332 }
13333 fn visit_integer_terminal_super(
13334 &mut self,
13335 terminal: Integer,
13336 data: TerminalData,
13337 tree: &F,
13338 ) -> Result<(), V::Error> {
13339 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13340 Ok(())
13341 }
13342 fn visit_float_terminal_super(
13343 &mut self,
13344 terminal: Float,
13345 data: TerminalData,
13346 tree: &F,
13347 ) -> Result<(), V::Error> {
13348 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13349 Ok(())
13350 }
13351 fn visit_inf_terminal_super(
13352 &mut self,
13353 terminal: Inf,
13354 data: TerminalData,
13355 tree: &F,
13356 ) -> Result<(), V::Error> {
13357 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13358 Ok(())
13359 }
13360 fn visit_na_n_terminal_super(
13361 &mut self,
13362 terminal: NaN,
13363 data: TerminalData,
13364 tree: &F,
13365 ) -> Result<(), V::Error> {
13366 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13367 Ok(())
13368 }
13369 fn visit_true_terminal_super(
13370 &mut self,
13371 terminal: True,
13372 data: TerminalData,
13373 tree: &F,
13374 ) -> Result<(), V::Error> {
13375 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13376 Ok(())
13377 }
13378 fn visit_false_terminal_super(
13379 &mut self,
13380 terminal: False,
13381 data: TerminalData,
13382 tree: &F,
13383 ) -> Result<(), V::Error> {
13384 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13385 Ok(())
13386 }
13387 fn visit_null_terminal_super(
13388 &mut self,
13389 terminal: Null,
13390 data: TerminalData,
13391 tree: &F,
13392 ) -> Result<(), V::Error> {
13393 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13394 Ok(())
13395 }
13396 fn visit_hole_terminal_super(
13397 &mut self,
13398 terminal: Hole,
13399 data: TerminalData,
13400 tree: &F,
13401 ) -> Result<(), V::Error> {
13402 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13403 Ok(())
13404 }
13405 fn visit_str_terminal_super(
13406 &mut self,
13407 terminal: Str,
13408 data: TerminalData,
13409 tree: &F,
13410 ) -> Result<(), V::Error> {
13411 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13412 Ok(())
13413 }
13414 fn visit_lit_str_terminal_super(
13415 &mut self,
13416 terminal: LitStr,
13417 data: TerminalData,
13418 tree: &F,
13419 ) -> Result<(), V::Error> {
13420 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13421 Ok(())
13422 }
13423 fn visit_text_terminal_super(
13424 &mut self,
13425 terminal: Text,
13426 data: TerminalData,
13427 tree: &F,
13428 ) -> Result<(), V::Error> {
13429 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13430 Ok(())
13431 }
13432 fn visit_inline_code_1_terminal_super(
13433 &mut self,
13434 terminal: InlineCode1,
13435 data: TerminalData,
13436 tree: &F,
13437 ) -> Result<(), V::Error> {
13438 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13439 Ok(())
13440 }
13441 fn visit_lit_str_3_start_terminal_super(
13442 &mut self,
13443 terminal: LitStr3Start,
13444 data: TerminalData,
13445 tree: &F,
13446 ) -> Result<(), V::Error> {
13447 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13448 Ok(())
13449 }
13450 fn visit_lit_str_2_start_terminal_super(
13451 &mut self,
13452 terminal: LitStr2Start,
13453 data: TerminalData,
13454 tree: &F,
13455 ) -> Result<(), V::Error> {
13456 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13457 Ok(())
13458 }
13459 fn visit_lit_str_1_start_terminal_super(
13460 &mut self,
13461 terminal: LitStr1Start,
13462 data: TerminalData,
13463 tree: &F,
13464 ) -> Result<(), V::Error> {
13465 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13466 Ok(())
13467 }
13468 fn visit_delim_code_start_3_terminal_super(
13469 &mut self,
13470 terminal: DelimCodeStart3,
13471 data: TerminalData,
13472 tree: &F,
13473 ) -> Result<(), V::Error> {
13474 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13475 Ok(())
13476 }
13477 fn visit_delim_code_start_2_terminal_super(
13478 &mut self,
13479 terminal: DelimCodeStart2,
13480 data: TerminalData,
13481 tree: &F,
13482 ) -> Result<(), V::Error> {
13483 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13484 Ok(())
13485 }
13486 fn visit_delim_code_start_1_terminal_super(
13487 &mut self,
13488 terminal: DelimCodeStart1,
13489 data: TerminalData,
13490 tree: &F,
13491 ) -> Result<(), V::Error> {
13492 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13493 Ok(())
13494 }
13495 fn visit_code_block_start_3_terminal_super(
13496 &mut self,
13497 terminal: CodeBlockStart3,
13498 data: TerminalData,
13499 tree: &F,
13500 ) -> Result<(), V::Error> {
13501 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13502 Ok(())
13503 }
13504 fn visit_code_block_start_4_terminal_super(
13505 &mut self,
13506 terminal: CodeBlockStart4,
13507 data: TerminalData,
13508 tree: &F,
13509 ) -> Result<(), V::Error> {
13510 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13511 Ok(())
13512 }
13513 fn visit_code_block_start_5_terminal_super(
13514 &mut self,
13515 terminal: CodeBlockStart5,
13516 data: TerminalData,
13517 tree: &F,
13518 ) -> Result<(), V::Error> {
13519 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13520 Ok(())
13521 }
13522 fn visit_code_block_start_6_terminal_super(
13523 &mut self,
13524 terminal: CodeBlockStart6,
13525 data: TerminalData,
13526 tree: &F,
13527 ) -> Result<(), V::Error> {
13528 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13529 Ok(())
13530 }
13531 fn visit_code_block_end_3_terminal_super(
13532 &mut self,
13533 terminal: CodeBlockEnd3,
13534 data: TerminalData,
13535 tree: &F,
13536 ) -> Result<(), V::Error> {
13537 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13538 Ok(())
13539 }
13540 fn visit_backtick_2_terminal_super(
13541 &mut self,
13542 terminal: Backtick2,
13543 data: TerminalData,
13544 tree: &F,
13545 ) -> Result<(), V::Error> {
13546 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13547 Ok(())
13548 }
13549 fn visit_code_block_end_4_terminal_super(
13550 &mut self,
13551 terminal: CodeBlockEnd4,
13552 data: TerminalData,
13553 tree: &F,
13554 ) -> Result<(), V::Error> {
13555 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13556 Ok(())
13557 }
13558 fn visit_backtick_3_terminal_super(
13559 &mut self,
13560 terminal: Backtick3,
13561 data: TerminalData,
13562 tree: &F,
13563 ) -> Result<(), V::Error> {
13564 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13565 Ok(())
13566 }
13567 fn visit_code_block_end_5_terminal_super(
13568 &mut self,
13569 terminal: CodeBlockEnd5,
13570 data: TerminalData,
13571 tree: &F,
13572 ) -> Result<(), V::Error> {
13573 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13574 Ok(())
13575 }
13576 fn visit_backtick_4_terminal_super(
13577 &mut self,
13578 terminal: Backtick4,
13579 data: TerminalData,
13580 tree: &F,
13581 ) -> Result<(), V::Error> {
13582 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13583 Ok(())
13584 }
13585 fn visit_code_block_end_6_terminal_super(
13586 &mut self,
13587 terminal: CodeBlockEnd6,
13588 data: TerminalData,
13589 tree: &F,
13590 ) -> Result<(), V::Error> {
13591 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13592 Ok(())
13593 }
13594 fn visit_backtick_5_terminal_super(
13595 &mut self,
13596 terminal: Backtick5,
13597 data: TerminalData,
13598 tree: &F,
13599 ) -> Result<(), V::Error> {
13600 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13601 Ok(())
13602 }
13603 fn visit_no_backtick_terminal_super(
13604 &mut self,
13605 terminal: NoBacktick,
13606 data: TerminalData,
13607 tree: &F,
13608 ) -> Result<(), V::Error> {
13609 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13610 Ok(())
13611 }
13612 fn visit_lit_str_3_end_terminal_super(
13613 &mut self,
13614 terminal: LitStr3End,
13615 data: TerminalData,
13616 tree: &F,
13617 ) -> Result<(), V::Error> {
13618 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13619 Ok(())
13620 }
13621 fn visit_lit_str_2_end_terminal_super(
13622 &mut self,
13623 terminal: LitStr2End,
13624 data: TerminalData,
13625 tree: &F,
13626 ) -> Result<(), V::Error> {
13627 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13628 Ok(())
13629 }
13630 fn visit_lit_str_1_end_terminal_super(
13631 &mut self,
13632 terminal: LitStr1End,
13633 data: TerminalData,
13634 tree: &F,
13635 ) -> Result<(), V::Error> {
13636 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13637 Ok(())
13638 }
13639 fn visit_s_quote_terminal_super(
13640 &mut self,
13641 terminal: SQuote,
13642 data: TerminalData,
13643 tree: &F,
13644 ) -> Result<(), V::Error> {
13645 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13646 Ok(())
13647 }
13648 fn visit_no_s_quote_terminal_super(
13649 &mut self,
13650 terminal: NoSQuote,
13651 data: TerminalData,
13652 tree: &F,
13653 ) -> Result<(), V::Error> {
13654 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13655 Ok(())
13656 }
13657 fn visit_delim_code_end_3_terminal_super(
13658 &mut self,
13659 terminal: DelimCodeEnd3,
13660 data: TerminalData,
13661 tree: &F,
13662 ) -> Result<(), V::Error> {
13663 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13664 Ok(())
13665 }
13666 fn visit_delim_code_end_2_terminal_super(
13667 &mut self,
13668 terminal: DelimCodeEnd2,
13669 data: TerminalData,
13670 tree: &F,
13671 ) -> Result<(), V::Error> {
13672 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13673 Ok(())
13674 }
13675 fn visit_delim_code_end_1_terminal_super(
13676 &mut self,
13677 terminal: DelimCodeEnd1,
13678 data: TerminalData,
13679 tree: &F,
13680 ) -> Result<(), V::Error> {
13681 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13682 Ok(())
13683 }
13684 fn visit_backtick_delim_terminal_super(
13685 &mut self,
13686 terminal: BacktickDelim,
13687 data: TerminalData,
13688 tree: &F,
13689 ) -> Result<(), V::Error> {
13690 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13691 Ok(())
13692 }
13693 fn visit_grammar_newline_terminal_super(
13694 &mut self,
13695 terminal: GrammarNewline,
13696 data: TerminalData,
13697 tree: &F,
13698 ) -> Result<(), V::Error> {
13699 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13700 Ok(())
13701 }
13702 fn visit_ws_terminal_super(
13703 &mut self,
13704 terminal: Ws,
13705 data: TerminalData,
13706 tree: &F,
13707 ) -> Result<(), V::Error> {
13708 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13709 Ok(())
13710 }
13711 fn visit_at_terminal_super(
13712 &mut self,
13713 terminal: At,
13714 data: TerminalData,
13715 tree: &F,
13716 ) -> Result<(), V::Error> {
13717 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13718 Ok(())
13719 }
13720 fn visit_dollar_terminal_super(
13721 &mut self,
13722 terminal: Dollar,
13723 data: TerminalData,
13724 tree: &F,
13725 ) -> Result<(), V::Error> {
13726 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13727 Ok(())
13728 }
13729 fn visit_dot_terminal_super(
13730 &mut self,
13731 terminal: Dot,
13732 data: TerminalData,
13733 tree: &F,
13734 ) -> Result<(), V::Error> {
13735 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13736 Ok(())
13737 }
13738 fn visit_l_brace_terminal_super(
13739 &mut self,
13740 terminal: LBrace,
13741 data: TerminalData,
13742 tree: &F,
13743 ) -> Result<(), V::Error> {
13744 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13745 Ok(())
13746 }
13747 fn visit_r_brace_terminal_super(
13748 &mut self,
13749 terminal: RBrace,
13750 data: TerminalData,
13751 tree: &F,
13752 ) -> Result<(), V::Error> {
13753 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13754 Ok(())
13755 }
13756 fn visit_l_bracket_terminal_super(
13757 &mut self,
13758 terminal: LBracket,
13759 data: TerminalData,
13760 tree: &F,
13761 ) -> Result<(), V::Error> {
13762 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13763 Ok(())
13764 }
13765 fn visit_r_bracket_terminal_super(
13766 &mut self,
13767 terminal: RBracket,
13768 data: TerminalData,
13769 tree: &F,
13770 ) -> Result<(), V::Error> {
13771 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13772 Ok(())
13773 }
13774 fn visit_l_paren_terminal_super(
13775 &mut self,
13776 terminal: LParen,
13777 data: TerminalData,
13778 tree: &F,
13779 ) -> Result<(), V::Error> {
13780 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13781 Ok(())
13782 }
13783 fn visit_r_paren_terminal_super(
13784 &mut self,
13785 terminal: RParen,
13786 data: TerminalData,
13787 tree: &F,
13788 ) -> Result<(), V::Error> {
13789 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13790 Ok(())
13791 }
13792 fn visit_newline_bind_terminal_super(
13793 &mut self,
13794 terminal: NewlineBind,
13795 data: TerminalData,
13796 tree: &F,
13797 ) -> Result<(), V::Error> {
13798 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13799 Ok(())
13800 }
13801 fn visit_bind_terminal_super(
13802 &mut self,
13803 terminal: Bind,
13804 data: TerminalData,
13805 tree: &F,
13806 ) -> Result<(), V::Error> {
13807 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13808 Ok(())
13809 }
13810 fn visit_comma_terminal_super(
13811 &mut self,
13812 terminal: Comma,
13813 data: TerminalData,
13814 tree: &F,
13815 ) -> Result<(), V::Error> {
13816 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13817 Ok(())
13818 }
13819 fn visit_esc_terminal_super(
13820 &mut self,
13821 terminal: Esc,
13822 data: TerminalData,
13823 tree: &F,
13824 ) -> Result<(), V::Error> {
13825 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13826 Ok(())
13827 }
13828 fn visit_newline_text_start_terminal_super(
13829 &mut self,
13830 terminal: NewlineTextStart,
13831 data: TerminalData,
13832 tree: &F,
13833 ) -> Result<(), V::Error> {
13834 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13835 Ok(())
13836 }
13837 fn visit_text_start_terminal_super(
13838 &mut self,
13839 terminal: TextStart,
13840 data: TerminalData,
13841 tree: &F,
13842 ) -> Result<(), V::Error> {
13843 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13844 Ok(())
13845 }
13846 fn visit_ident_terminal_super(
13847 &mut self,
13848 terminal: Ident,
13849 data: TerminalData,
13850 tree: &F,
13851 ) -> Result<(), V::Error> {
13852 self.visit_terminal(terminal.0, terminal.kind(), data, tree)?;
13853 Ok(())
13854 }
13855 fn visit_non_terminal_super(
13856 &mut self,
13857 _id: CstNodeId,
13858 _kind: NonTerminalKind,
13859 _data: NonTerminalData,
13860 _tree: &F,
13861 ) -> Result<(), V::Error> {
13862 Ok(())
13863 }
13864 fn visit_non_terminal_close_super(
13865 &mut self,
13866 _id: CstNodeId,
13867 _kind: NonTerminalKind,
13868 _data: NonTerminalData,
13869 _tree: &F,
13870 ) -> Result<(), V::Error> {
13871 Ok(())
13872 }
13873 fn visit_terminal_super(
13874 &mut self,
13875 _id: CstNodeId,
13876 _kind: TerminalKind,
13877 _data: TerminalData,
13878 _tree: &F,
13879 ) -> Result<(), V::Error> {
13880 Ok(())
13881 }
13882 fn recover_error(
13883 &mut self,
13884 node_data: Option<CstNode>,
13885 id: CstNodeId,
13886 kind: NodeKind,
13887 tree: &F,
13888 ) -> Result<(), V::Error> {
13889 let Some(node_data) = node_data else {
13890 return Ok(());
13891 };
13892 if node_data.node_kind() == kind {
13893 for child in tree.children(id) {
13894 if let Some(node_data) = tree.node_data(child) {
13895 self.visit_any(child, node_data, tree)?;
13896 }
13897 }
13898 } else {
13899 self.visit_any(id, node_data, tree)?;
13900 }
13901 Ok(())
13902 }
13903 fn visit_any(&mut self, id: CstNodeId, node: CstNode, tree: &F) -> Result<(), V::Error> {
13904 match node {
13905 CstNode::NonTerminal { kind, .. } => match kind {
13906 NonTerminalKind::Array => {
13907 let handle = ArrayHandle(id);
13908 self.visit_array_handle(handle, tree)?;
13909 }
13910 NonTerminalKind::ArrayBegin => {
13911 let handle = ArrayBeginHandle(id);
13912 self.visit_array_begin_handle(handle, tree)?;
13913 }
13914 NonTerminalKind::ArrayElements => {
13915 let handle = ArrayElementsHandle(id);
13916 self.visit_array_elements_handle(handle, tree)?;
13917 }
13918 NonTerminalKind::ArrayElementsOpt => {
13919 let handle = ArrayElementsOptHandle(id);
13920 self.visit_array_elements_opt_handle(handle, tree)?;
13921 }
13922 NonTerminalKind::ArrayElementsTail => {
13923 let handle = ArrayElementsTailHandle(id);
13924 self.visit_array_elements_tail_handle(handle, tree)?;
13925 }
13926 NonTerminalKind::ArrayElementsTailOpt => {
13927 let handle = ArrayElementsTailOptHandle(id);
13928 self.visit_array_elements_tail_opt_handle(handle, tree)?;
13929 }
13930 NonTerminalKind::ArrayEnd => {
13931 let handle = ArrayEndHandle(id);
13932 self.visit_array_end_handle(handle, tree)?;
13933 }
13934 NonTerminalKind::ArrayMarker => {
13935 let handle = ArrayMarkerHandle(id);
13936 self.visit_array_marker_handle(handle, tree)?;
13937 }
13938 NonTerminalKind::ArrayMarkerOpt => {
13939 let handle = ArrayMarkerOptHandle(id);
13940 self.visit_array_marker_opt_handle(handle, tree)?;
13941 }
13942 NonTerminalKind::ArrayOpt => {
13943 let handle = ArrayOptHandle(id);
13944 self.visit_array_opt_handle(handle, tree)?;
13945 }
13946 NonTerminalKind::At => {
13947 let handle = AtHandle(id);
13948 self.visit_at_handle(handle, tree)?;
13949 }
13950 NonTerminalKind::Backtick2 => {
13951 let handle = Backtick2Handle(id);
13952 self.visit_backtick_2_handle(handle, tree)?;
13953 }
13954 NonTerminalKind::Backtick3 => {
13955 let handle = Backtick3Handle(id);
13956 self.visit_backtick_3_handle(handle, tree)?;
13957 }
13958 NonTerminalKind::Backtick4 => {
13959 let handle = Backtick4Handle(id);
13960 self.visit_backtick_4_handle(handle, tree)?;
13961 }
13962 NonTerminalKind::Backtick5 => {
13963 let handle = Backtick5Handle(id);
13964 self.visit_backtick_5_handle(handle, tree)?;
13965 }
13966 NonTerminalKind::BacktickDelim => {
13967 let handle = BacktickDelimHandle(id);
13968 self.visit_backtick_delim_handle(handle, tree)?;
13969 }
13970 NonTerminalKind::Begin => {
13971 let handle = BeginHandle(id);
13972 self.visit_begin_handle(handle, tree)?;
13973 }
13974 NonTerminalKind::Bind => {
13975 let handle = BindHandle(id);
13976 self.visit_bind_handle(handle, tree)?;
13977 }
13978 NonTerminalKind::Binding => {
13979 let handle = BindingHandle(id);
13980 self.visit_binding_handle(handle, tree)?;
13981 }
13982 NonTerminalKind::BindingRhs => {
13983 let handle = BindingRhsHandle(id);
13984 self.visit_binding_rhs_handle(handle, tree)?;
13985 }
13986 NonTerminalKind::BlockBody => {
13987 let handle = BlockBodyHandle(id);
13988 self.visit_block_body_handle(handle, tree)?;
13989 }
13990 NonTerminalKind::Boolean => {
13991 let handle = BooleanHandle(id);
13992 self.visit_boolean_handle(handle, tree)?;
13993 }
13994 NonTerminalKind::CodeBlock => {
13995 let handle = CodeBlockHandle(id);
13996 self.visit_code_block_handle(handle, tree)?;
13997 }
13998 NonTerminalKind::CodeBlock3 => {
13999 let handle = CodeBlock3Handle(id);
14000 self.visit_code_block_3_handle(handle, tree)?;
14001 }
14002 NonTerminalKind::CodeBlock3List => {
14003 let handle = CodeBlock3ListHandle(id);
14004 self.visit_code_block_3_list_handle(handle, tree)?;
14005 }
14006 NonTerminalKind::CodeBlock3ListGroup => {
14007 let handle = CodeBlock3ListGroupHandle(id);
14008 self.visit_code_block_3_list_group_handle(handle, tree)?;
14009 }
14010 NonTerminalKind::CodeBlock4 => {
14011 let handle = CodeBlock4Handle(id);
14012 self.visit_code_block_4_handle(handle, tree)?;
14013 }
14014 NonTerminalKind::CodeBlock4List => {
14015 let handle = CodeBlock4ListHandle(id);
14016 self.visit_code_block_4_list_handle(handle, tree)?;
14017 }
14018 NonTerminalKind::CodeBlock4ListGroup => {
14019 let handle = CodeBlock4ListGroupHandle(id);
14020 self.visit_code_block_4_list_group_handle(handle, tree)?;
14021 }
14022 NonTerminalKind::CodeBlock5 => {
14023 let handle = CodeBlock5Handle(id);
14024 self.visit_code_block_5_handle(handle, tree)?;
14025 }
14026 NonTerminalKind::CodeBlock5List => {
14027 let handle = CodeBlock5ListHandle(id);
14028 self.visit_code_block_5_list_handle(handle, tree)?;
14029 }
14030 NonTerminalKind::CodeBlock5ListGroup => {
14031 let handle = CodeBlock5ListGroupHandle(id);
14032 self.visit_code_block_5_list_group_handle(handle, tree)?;
14033 }
14034 NonTerminalKind::CodeBlock6 => {
14035 let handle = CodeBlock6Handle(id);
14036 self.visit_code_block_6_handle(handle, tree)?;
14037 }
14038 NonTerminalKind::CodeBlock6List => {
14039 let handle = CodeBlock6ListHandle(id);
14040 self.visit_code_block_6_list_handle(handle, tree)?;
14041 }
14042 NonTerminalKind::CodeBlock6ListGroup => {
14043 let handle = CodeBlock6ListGroupHandle(id);
14044 self.visit_code_block_6_list_group_handle(handle, tree)?;
14045 }
14046 NonTerminalKind::CodeBlockEnd3 => {
14047 let handle = CodeBlockEnd3Handle(id);
14048 self.visit_code_block_end_3_handle(handle, tree)?;
14049 }
14050 NonTerminalKind::CodeBlockEnd4 => {
14051 let handle = CodeBlockEnd4Handle(id);
14052 self.visit_code_block_end_4_handle(handle, tree)?;
14053 }
14054 NonTerminalKind::CodeBlockEnd5 => {
14055 let handle = CodeBlockEnd5Handle(id);
14056 self.visit_code_block_end_5_handle(handle, tree)?;
14057 }
14058 NonTerminalKind::CodeBlockEnd6 => {
14059 let handle = CodeBlockEnd6Handle(id);
14060 self.visit_code_block_end_6_handle(handle, tree)?;
14061 }
14062 NonTerminalKind::CodeBlockStart3 => {
14063 let handle = CodeBlockStart3Handle(id);
14064 self.visit_code_block_start_3_handle(handle, tree)?;
14065 }
14066 NonTerminalKind::CodeBlockStart4 => {
14067 let handle = CodeBlockStart4Handle(id);
14068 self.visit_code_block_start_4_handle(handle, tree)?;
14069 }
14070 NonTerminalKind::CodeBlockStart5 => {
14071 let handle = CodeBlockStart5Handle(id);
14072 self.visit_code_block_start_5_handle(handle, tree)?;
14073 }
14074 NonTerminalKind::CodeBlockStart6 => {
14075 let handle = CodeBlockStart6Handle(id);
14076 self.visit_code_block_start_6_handle(handle, tree)?;
14077 }
14078 NonTerminalKind::Comma => {
14079 let handle = CommaHandle(id);
14080 self.visit_comma_handle(handle, tree)?;
14081 }
14082 NonTerminalKind::Continue => {
14083 let handle = ContinueHandle(id);
14084 self.visit_continue_handle(handle, tree)?;
14085 }
14086 NonTerminalKind::DelimCode => {
14087 let handle = DelimCodeHandle(id);
14088 self.visit_delim_code_handle(handle, tree)?;
14089 }
14090 NonTerminalKind::DelimCode1 => {
14091 let handle = DelimCode1Handle(id);
14092 self.visit_delim_code_1_handle(handle, tree)?;
14093 }
14094 NonTerminalKind::DelimCode1List => {
14095 let handle = DelimCode1ListHandle(id);
14096 self.visit_delim_code_1_list_handle(handle, tree)?;
14097 }
14098 NonTerminalKind::DelimCode1ListGroup => {
14099 let handle = DelimCode1ListGroupHandle(id);
14100 self.visit_delim_code_1_list_group_handle(handle, tree)?;
14101 }
14102 NonTerminalKind::DelimCode2 => {
14103 let handle = DelimCode2Handle(id);
14104 self.visit_delim_code_2_handle(handle, tree)?;
14105 }
14106 NonTerminalKind::DelimCode2List => {
14107 let handle = DelimCode2ListHandle(id);
14108 self.visit_delim_code_2_list_handle(handle, tree)?;
14109 }
14110 NonTerminalKind::DelimCode2ListGroup => {
14111 let handle = DelimCode2ListGroupHandle(id);
14112 self.visit_delim_code_2_list_group_handle(handle, tree)?;
14113 }
14114 NonTerminalKind::DelimCode3 => {
14115 let handle = DelimCode3Handle(id);
14116 self.visit_delim_code_3_handle(handle, tree)?;
14117 }
14118 NonTerminalKind::DelimCode3List => {
14119 let handle = DelimCode3ListHandle(id);
14120 self.visit_delim_code_3_list_handle(handle, tree)?;
14121 }
14122 NonTerminalKind::DelimCode3ListGroup => {
14123 let handle = DelimCode3ListGroupHandle(id);
14124 self.visit_delim_code_3_list_group_handle(handle, tree)?;
14125 }
14126 NonTerminalKind::DelimCodeEnd1 => {
14127 let handle = DelimCodeEnd1Handle(id);
14128 self.visit_delim_code_end_1_handle(handle, tree)?;
14129 }
14130 NonTerminalKind::DelimCodeEnd2 => {
14131 let handle = DelimCodeEnd2Handle(id);
14132 self.visit_delim_code_end_2_handle(handle, tree)?;
14133 }
14134 NonTerminalKind::DelimCodeEnd3 => {
14135 let handle = DelimCodeEnd3Handle(id);
14136 self.visit_delim_code_end_3_handle(handle, tree)?;
14137 }
14138 NonTerminalKind::DelimCodeStart1 => {
14139 let handle = DelimCodeStart1Handle(id);
14140 self.visit_delim_code_start_1_handle(handle, tree)?;
14141 }
14142 NonTerminalKind::DelimCodeStart2 => {
14143 let handle = DelimCodeStart2Handle(id);
14144 self.visit_delim_code_start_2_handle(handle, tree)?;
14145 }
14146 NonTerminalKind::DelimCodeStart3 => {
14147 let handle = DelimCodeStart3Handle(id);
14148 self.visit_delim_code_start_3_handle(handle, tree)?;
14149 }
14150 NonTerminalKind::Dot => {
14151 let handle = DotHandle(id);
14152 self.visit_dot_handle(handle, tree)?;
14153 }
14154 NonTerminalKind::DotKey => {
14155 let handle = DotKeyHandle(id);
14156 self.visit_dot_key_handle(handle, tree)?;
14157 }
14158 NonTerminalKind::End => {
14159 let handle = EndHandle(id);
14160 self.visit_end_handle(handle, tree)?;
14161 }
14162 NonTerminalKind::Eure => {
14163 let handle = EureHandle(id);
14164 self.visit_eure_handle(handle, tree)?;
14165 }
14166 NonTerminalKind::EureList => {
14167 let handle = EureBindingsHandle(id);
14168 self.visit_eure_bindings_handle(handle, tree)?;
14169 }
14170 NonTerminalKind::EureList0 => {
14171 let handle = EureSectionsHandle(id);
14172 self.visit_eure_sections_handle(handle, tree)?;
14173 }
14174 NonTerminalKind::EureOpt => {
14175 let handle = EureOptHandle(id);
14176 self.visit_eure_opt_handle(handle, tree)?;
14177 }
14178 NonTerminalKind::Ext => {
14179 let handle = ExtHandle(id);
14180 self.visit_ext_handle(handle, tree)?;
14181 }
14182 NonTerminalKind::ExtensionNameSpace => {
14183 let handle = ExtensionNameSpaceHandle(id);
14184 self.visit_extension_name_space_handle(handle, tree)?;
14185 }
14186 NonTerminalKind::False => {
14187 let handle = FalseHandle(id);
14188 self.visit_false_handle(handle, tree)?;
14189 }
14190 NonTerminalKind::FirstKey => {
14191 let handle = FirstKeyHandle(id);
14192 self.visit_first_key_handle(handle, tree)?;
14193 }
14194 NonTerminalKind::FlatBody => {
14195 let handle = FlatBodyHandle(id);
14196 self.visit_flat_body_handle(handle, tree)?;
14197 }
14198 NonTerminalKind::FlatBodyList => {
14199 let handle = FlatBodyListHandle(id);
14200 self.visit_flat_body_list_handle(handle, tree)?;
14201 }
14202 NonTerminalKind::FlatRootBinding => {
14203 let handle = FlatRootBindingHandle(id);
14204 self.visit_flat_root_binding_handle(handle, tree)?;
14205 }
14206 NonTerminalKind::Float => {
14207 let handle = FloatHandle(id);
14208 self.visit_float_handle(handle, tree)?;
14209 }
14210 NonTerminalKind::GrammarNewline => {
14211 let handle = GrammarNewlineHandle(id);
14212 self.visit_grammar_newline_handle(handle, tree)?;
14213 }
14214 NonTerminalKind::Hole => {
14215 let handle = HoleHandle(id);
14216 self.visit_hole_handle(handle, tree)?;
14217 }
14218 NonTerminalKind::Ident => {
14219 let handle = IdentHandle(id);
14220 self.visit_ident_handle(handle, tree)?;
14221 }
14222 NonTerminalKind::Inf => {
14223 let handle = InfHandle(id);
14224 self.visit_inf_handle(handle, tree)?;
14225 }
14226 NonTerminalKind::InlineCode => {
14227 let handle = InlineCodeHandle(id);
14228 self.visit_inline_code_handle(handle, tree)?;
14229 }
14230 NonTerminalKind::InlineCode1 => {
14231 let handle = InlineCode1Handle(id);
14232 self.visit_inline_code_1_handle(handle, tree)?;
14233 }
14234 NonTerminalKind::Integer => {
14235 let handle = IntegerHandle(id);
14236 self.visit_integer_handle(handle, tree)?;
14237 }
14238 NonTerminalKind::Key => {
14239 let handle = KeyHandle(id);
14240 self.visit_key_handle(handle, tree)?;
14241 }
14242 NonTerminalKind::KeyIdent => {
14243 let handle = KeyIdentHandle(id);
14244 self.visit_key_ident_handle(handle, tree)?;
14245 }
14246 NonTerminalKind::KeyTail => {
14247 let handle = KeyTailHandle(id);
14248 self.visit_key_tail_handle(handle, tree)?;
14249 }
14250 NonTerminalKind::KeyTuple => {
14251 let handle = KeyTupleHandle(id);
14252 self.visit_key_tuple_handle(handle, tree)?;
14253 }
14254 NonTerminalKind::KeyTupleElements => {
14255 let handle = KeyTupleElementsHandle(id);
14256 self.visit_key_tuple_elements_handle(handle, tree)?;
14257 }
14258 NonTerminalKind::KeyTupleElementsOpt => {
14259 let handle = KeyTupleElementsOptHandle(id);
14260 self.visit_key_tuple_elements_opt_handle(handle, tree)?;
14261 }
14262 NonTerminalKind::KeyTupleElementsTail => {
14263 let handle = KeyTupleElementsTailHandle(id);
14264 self.visit_key_tuple_elements_tail_handle(handle, tree)?;
14265 }
14266 NonTerminalKind::KeyTupleElementsTailOpt => {
14267 let handle = KeyTupleElementsTailOptHandle(id);
14268 self.visit_key_tuple_elements_tail_opt_handle(handle, tree)?;
14269 }
14270 NonTerminalKind::KeyTupleOpt => {
14271 let handle = KeyTupleOptHandle(id);
14272 self.visit_key_tuple_opt_handle(handle, tree)?;
14273 }
14274 NonTerminalKind::KeyValue => {
14275 let handle = KeyValueHandle(id);
14276 self.visit_key_value_handle(handle, tree)?;
14277 }
14278 NonTerminalKind::Keys => {
14279 let handle = KeysHandle(id);
14280 self.visit_keys_handle(handle, tree)?;
14281 }
14282 NonTerminalKind::KeysList => {
14283 let handle = KeysListHandle(id);
14284 self.visit_keys_list_handle(handle, tree)?;
14285 }
14286 NonTerminalKind::LParen => {
14287 let handle = LParenHandle(id);
14288 self.visit_l_paren_handle(handle, tree)?;
14289 }
14290 NonTerminalKind::LitStr => {
14291 let handle = LitStrHandle(id);
14292 self.visit_lit_str_handle(handle, tree)?;
14293 }
14294 NonTerminalKind::LitStr1 => {
14295 let handle = LitStr1Handle(id);
14296 self.visit_lit_str_1_handle(handle, tree)?;
14297 }
14298 NonTerminalKind::LitStr1End => {
14299 let handle = LitStr1EndHandle(id);
14300 self.visit_lit_str_1_end_handle(handle, tree)?;
14301 }
14302 NonTerminalKind::LitStr1List => {
14303 let handle = LitStr1ListHandle(id);
14304 self.visit_lit_str_1_list_handle(handle, tree)?;
14305 }
14306 NonTerminalKind::LitStr1ListGroup => {
14307 let handle = LitStr1ListGroupHandle(id);
14308 self.visit_lit_str_1_list_group_handle(handle, tree)?;
14309 }
14310 NonTerminalKind::LitStr1Start => {
14311 let handle = LitStr1StartHandle(id);
14312 self.visit_lit_str_1_start_handle(handle, tree)?;
14313 }
14314 NonTerminalKind::LitStr2 => {
14315 let handle = LitStr2Handle(id);
14316 self.visit_lit_str_2_handle(handle, tree)?;
14317 }
14318 NonTerminalKind::LitStr2End => {
14319 let handle = LitStr2EndHandle(id);
14320 self.visit_lit_str_2_end_handle(handle, tree)?;
14321 }
14322 NonTerminalKind::LitStr2List => {
14323 let handle = LitStr2ListHandle(id);
14324 self.visit_lit_str_2_list_handle(handle, tree)?;
14325 }
14326 NonTerminalKind::LitStr2ListGroup => {
14327 let handle = LitStr2ListGroupHandle(id);
14328 self.visit_lit_str_2_list_group_handle(handle, tree)?;
14329 }
14330 NonTerminalKind::LitStr2Start => {
14331 let handle = LitStr2StartHandle(id);
14332 self.visit_lit_str_2_start_handle(handle, tree)?;
14333 }
14334 NonTerminalKind::LitStr3 => {
14335 let handle = LitStr3Handle(id);
14336 self.visit_lit_str_3_handle(handle, tree)?;
14337 }
14338 NonTerminalKind::LitStr3End => {
14339 let handle = LitStr3EndHandle(id);
14340 self.visit_lit_str_3_end_handle(handle, tree)?;
14341 }
14342 NonTerminalKind::LitStr3List => {
14343 let handle = LitStr3ListHandle(id);
14344 self.visit_lit_str_3_list_handle(handle, tree)?;
14345 }
14346 NonTerminalKind::LitStr3ListGroup => {
14347 let handle = LitStr3ListGroupHandle(id);
14348 self.visit_lit_str_3_list_group_handle(handle, tree)?;
14349 }
14350 NonTerminalKind::LitStr3Start => {
14351 let handle = LitStr3StartHandle(id);
14352 self.visit_lit_str_3_start_handle(handle, tree)?;
14353 }
14354 NonTerminalKind::MapBind => {
14355 let handle = MapBindHandle(id);
14356 self.visit_map_bind_handle(handle, tree)?;
14357 }
14358 NonTerminalKind::NaN => {
14359 let handle = NaNHandle(id);
14360 self.visit_na_n_handle(handle, tree)?;
14361 }
14362 NonTerminalKind::NewlineBind => {
14363 let handle = NewlineBindHandle(id);
14364 self.visit_newline_bind_handle(handle, tree)?;
14365 }
14366 NonTerminalKind::NewlineHead => {
14367 let handle = NewlineHeadHandle(id);
14368 self.visit_newline_head_handle(handle, tree)?;
14369 }
14370 NonTerminalKind::NewlineHeadOpt => {
14371 let handle = NewlineHeadOptHandle(id);
14372 self.visit_newline_head_opt_handle(handle, tree)?;
14373 }
14374 NonTerminalKind::NewlineTextStart => {
14375 let handle = NewlineTextStartHandle(id);
14376 self.visit_newline_text_start_handle(handle, tree)?;
14377 }
14378 NonTerminalKind::NoBacktick => {
14379 let handle = NoBacktickHandle(id);
14380 self.visit_no_backtick_handle(handle, tree)?;
14381 }
14382 NonTerminalKind::NoSQuote => {
14383 let handle = NoSQuoteHandle(id);
14384 self.visit_no_s_quote_handle(handle, tree)?;
14385 }
14386 NonTerminalKind::Null => {
14387 let handle = NullHandle(id);
14388 self.visit_null_handle(handle, tree)?;
14389 }
14390 NonTerminalKind::Number => {
14391 let handle = NumberHandle(id);
14392 self.visit_number_handle(handle, tree)?;
14393 }
14394 NonTerminalKind::Object => {
14395 let handle = ObjectHandle(id);
14396 self.visit_object_handle(handle, tree)?;
14397 }
14398 NonTerminalKind::ObjectList => {
14399 let handle = ObjectListHandle(id);
14400 self.visit_object_list_handle(handle, tree)?;
14401 }
14402 NonTerminalKind::ObjectOpt => {
14403 let handle = ObjectOptHandle(id);
14404 self.visit_object_opt_handle(handle, tree)?;
14405 }
14406 NonTerminalKind::ObjectOpt0 => {
14407 let handle = ObjectOpt0Handle(id);
14408 self.visit_object_opt_0_handle(handle, tree)?;
14409 }
14410 NonTerminalKind::ObjectOpt1 => {
14411 let handle = ObjectOpt1Handle(id);
14412 self.visit_object_opt_1_handle(handle, tree)?;
14413 }
14414 NonTerminalKind::RParen => {
14415 let handle = RParenHandle(id);
14416 self.visit_r_paren_handle(handle, tree)?;
14417 }
14418 NonTerminalKind::RootBinding => {
14419 let handle = RootBindingHandle(id);
14420 self.visit_root_binding_handle(handle, tree)?;
14421 }
14422 NonTerminalKind::RootTextBinding => {
14423 let handle = RootTextBindingHandle(id);
14424 self.visit_root_text_binding_handle(handle, tree)?;
14425 }
14426 NonTerminalKind::RootTextBindingOpt => {
14427 let handle = RootTextBindingOptHandle(id);
14428 self.visit_root_text_binding_opt_handle(handle, tree)?;
14429 }
14430 NonTerminalKind::RootTextBindingOpt0 => {
14431 let handle = RootTextBindingOpt0Handle(id);
14432 self.visit_root_text_binding_opt_0_handle(handle, tree)?;
14433 }
14434 NonTerminalKind::RootTextBindingOpt1 => {
14435 let handle = RootTextBindingOpt1Handle(id);
14436 self.visit_root_text_binding_opt_1_handle(handle, tree)?;
14437 }
14438 NonTerminalKind::RootValueBinding => {
14439 let handle = RootValueBindingHandle(id);
14440 self.visit_root_value_binding_handle(handle, tree)?;
14441 }
14442 NonTerminalKind::SQuote => {
14443 let handle = SQuoteHandle(id);
14444 self.visit_s_quote_handle(handle, tree)?;
14445 }
14446 NonTerminalKind::Section => {
14447 let handle = SectionHandle(id);
14448 self.visit_section_handle(handle, tree)?;
14449 }
14450 NonTerminalKind::SectionBinding => {
14451 let handle = SectionBindingHandle(id);
14452 self.visit_section_binding_handle(handle, tree)?;
14453 }
14454 NonTerminalKind::SectionBody => {
14455 let handle = SectionBodyHandle(id);
14456 self.visit_section_body_handle(handle, tree)?;
14457 }
14458 NonTerminalKind::SectionBodyOpt => {
14459 let handle = SectionBodyOptHandle(id);
14460 self.visit_section_body_opt_handle(handle, tree)?;
14461 }
14462 NonTerminalKind::SectionHead => {
14463 let handle = SectionHeadHandle(id);
14464 self.visit_section_head_handle(handle, tree)?;
14465 }
14466 NonTerminalKind::Str => {
14467 let handle = StrHandle(id);
14468 self.visit_str_handle(handle, tree)?;
14469 }
14470 NonTerminalKind::String => {
14471 let handle = StringHandle(id);
14472 self.visit_string_handle(handle, tree)?;
14473 }
14474 NonTerminalKind::Strings => {
14475 let handle = StringsHandle(id);
14476 self.visit_strings_handle(handle, tree)?;
14477 }
14478 NonTerminalKind::StringsList => {
14479 let handle = StringsListHandle(id);
14480 self.visit_strings_list_handle(handle, tree)?;
14481 }
14482 NonTerminalKind::Text => {
14483 let handle = TextHandle(id);
14484 self.visit_text_handle(handle, tree)?;
14485 }
14486 NonTerminalKind::TextBinding => {
14487 let handle = TextBindingHandle(id);
14488 self.visit_text_binding_handle(handle, tree)?;
14489 }
14490 NonTerminalKind::TextBindingOpt => {
14491 let handle = TextBindingOptHandle(id);
14492 self.visit_text_binding_opt_handle(handle, tree)?;
14493 }
14494 NonTerminalKind::TextBindingOpt0 => {
14495 let handle = TextBindingOpt0Handle(id);
14496 self.visit_text_binding_opt_0_handle(handle, tree)?;
14497 }
14498 NonTerminalKind::TextBindingOpt1 => {
14499 let handle = TextBindingOpt1Handle(id);
14500 self.visit_text_binding_opt_1_handle(handle, tree)?;
14501 }
14502 NonTerminalKind::TextStart => {
14503 let handle = TextStartHandle(id);
14504 self.visit_text_start_handle(handle, tree)?;
14505 }
14506 NonTerminalKind::TopLevelBinding => {
14507 let handle = TopLevelBindingHandle(id);
14508 self.visit_top_level_binding_handle(handle, tree)?;
14509 }
14510 NonTerminalKind::True => {
14511 let handle = TrueHandle(id);
14512 self.visit_true_handle(handle, tree)?;
14513 }
14514 NonTerminalKind::Tuple => {
14515 let handle = TupleHandle(id);
14516 self.visit_tuple_handle(handle, tree)?;
14517 }
14518 NonTerminalKind::TupleElements => {
14519 let handle = TupleElementsHandle(id);
14520 self.visit_tuple_elements_handle(handle, tree)?;
14521 }
14522 NonTerminalKind::TupleElementsOpt => {
14523 let handle = TupleElementsOptHandle(id);
14524 self.visit_tuple_elements_opt_handle(handle, tree)?;
14525 }
14526 NonTerminalKind::TupleElementsTail => {
14527 let handle = TupleElementsTailHandle(id);
14528 self.visit_tuple_elements_tail_handle(handle, tree)?;
14529 }
14530 NonTerminalKind::TupleElementsTailOpt => {
14531 let handle = TupleElementsTailOptHandle(id);
14532 self.visit_tuple_elements_tail_opt_handle(handle, tree)?;
14533 }
14534 NonTerminalKind::TupleIndex => {
14535 let handle = TupleIndexHandle(id);
14536 self.visit_tuple_index_handle(handle, tree)?;
14537 }
14538 NonTerminalKind::TupleOpt => {
14539 let handle = TupleOptHandle(id);
14540 self.visit_tuple_opt_handle(handle, tree)?;
14541 }
14542 NonTerminalKind::Value => {
14543 let handle = ValueHandle(id);
14544 self.visit_value_handle(handle, tree)?;
14545 }
14546 NonTerminalKind::ValueBinding => {
14547 let handle = ValueBindingHandle(id);
14548 self.visit_value_binding_handle(handle, tree)?;
14549 }
14550 NonTerminalKind::Ws => {
14551 let handle = WsHandle(id);
14552 self.visit_ws_handle(handle, tree)?;
14553 }
14554 NonTerminalKind::Root => {
14555 let handle = RootHandle(id);
14556 self.visit_root_handle(handle, tree)?;
14557 }
14558 },
14559 CstNode::Terminal { kind, data } => match kind {
14560 TerminalKind::NewLine => {
14561 let terminal = NewLine(id);
14562 self.visit_new_line_terminal(terminal, data, tree)?;
14563 }
14564 TerminalKind::Whitespace => {
14565 let terminal = Whitespace(id);
14566 self.visit_whitespace_terminal(terminal, data, tree)?;
14567 }
14568 TerminalKind::LineComment => {
14569 let terminal = LineComment(id);
14570 self.visit_line_comment_terminal(terminal, data, tree)?;
14571 }
14572 TerminalKind::BlockComment => {
14573 let terminal = BlockComment(id);
14574 self.visit_block_comment_terminal(terminal, data, tree)?;
14575 }
14576 TerminalKind::Hash => {
14577 let terminal = Hash(id);
14578 self.visit_hash_terminal(terminal, data, tree)?;
14579 }
14580 TerminalKind::MapBind => {
14581 let terminal = MapBind(id);
14582 self.visit_map_bind_terminal(terminal, data, tree)?;
14583 }
14584 TerminalKind::Integer => {
14585 let terminal = Integer(id);
14586 self.visit_integer_terminal(terminal, data, tree)?;
14587 }
14588 TerminalKind::Float => {
14589 let terminal = Float(id);
14590 self.visit_float_terminal(terminal, data, tree)?;
14591 }
14592 TerminalKind::Inf => {
14593 let terminal = Inf(id);
14594 self.visit_inf_terminal(terminal, data, tree)?;
14595 }
14596 TerminalKind::NaN => {
14597 let terminal = NaN(id);
14598 self.visit_na_n_terminal(terminal, data, tree)?;
14599 }
14600 TerminalKind::True => {
14601 let terminal = True(id);
14602 self.visit_true_terminal(terminal, data, tree)?;
14603 }
14604 TerminalKind::False => {
14605 let terminal = False(id);
14606 self.visit_false_terminal(terminal, data, tree)?;
14607 }
14608 TerminalKind::Null => {
14609 let terminal = Null(id);
14610 self.visit_null_terminal(terminal, data, tree)?;
14611 }
14612 TerminalKind::Hole => {
14613 let terminal = Hole(id);
14614 self.visit_hole_terminal(terminal, data, tree)?;
14615 }
14616 TerminalKind::Str => {
14617 let terminal = Str(id);
14618 self.visit_str_terminal(terminal, data, tree)?;
14619 }
14620 TerminalKind::LitStr => {
14621 let terminal = LitStr(id);
14622 self.visit_lit_str_terminal(terminal, data, tree)?;
14623 }
14624 TerminalKind::Text => {
14625 let terminal = Text(id);
14626 self.visit_text_terminal(terminal, data, tree)?;
14627 }
14628 TerminalKind::InlineCode1 => {
14629 let terminal = InlineCode1(id);
14630 self.visit_inline_code_1_terminal(terminal, data, tree)?;
14631 }
14632 TerminalKind::LitStr3Start => {
14633 let terminal = LitStr3Start(id);
14634 self.visit_lit_str_3_start_terminal(terminal, data, tree)?;
14635 }
14636 TerminalKind::LitStr2Start => {
14637 let terminal = LitStr2Start(id);
14638 self.visit_lit_str_2_start_terminal(terminal, data, tree)?;
14639 }
14640 TerminalKind::LitStr1Start => {
14641 let terminal = LitStr1Start(id);
14642 self.visit_lit_str_1_start_terminal(terminal, data, tree)?;
14643 }
14644 TerminalKind::DelimCodeStart3 => {
14645 let terminal = DelimCodeStart3(id);
14646 self.visit_delim_code_start_3_terminal(terminal, data, tree)?;
14647 }
14648 TerminalKind::DelimCodeStart2 => {
14649 let terminal = DelimCodeStart2(id);
14650 self.visit_delim_code_start_2_terminal(terminal, data, tree)?;
14651 }
14652 TerminalKind::DelimCodeStart1 => {
14653 let terminal = DelimCodeStart1(id);
14654 self.visit_delim_code_start_1_terminal(terminal, data, tree)?;
14655 }
14656 TerminalKind::CodeBlockStart3 => {
14657 let terminal = CodeBlockStart3(id);
14658 self.visit_code_block_start_3_terminal(terminal, data, tree)?;
14659 }
14660 TerminalKind::CodeBlockStart4 => {
14661 let terminal = CodeBlockStart4(id);
14662 self.visit_code_block_start_4_terminal(terminal, data, tree)?;
14663 }
14664 TerminalKind::CodeBlockStart5 => {
14665 let terminal = CodeBlockStart5(id);
14666 self.visit_code_block_start_5_terminal(terminal, data, tree)?;
14667 }
14668 TerminalKind::CodeBlockStart6 => {
14669 let terminal = CodeBlockStart6(id);
14670 self.visit_code_block_start_6_terminal(terminal, data, tree)?;
14671 }
14672 TerminalKind::CodeBlockEnd3 => {
14673 let terminal = CodeBlockEnd3(id);
14674 self.visit_code_block_end_3_terminal(terminal, data, tree)?;
14675 }
14676 TerminalKind::Backtick2 => {
14677 let terminal = Backtick2(id);
14678 self.visit_backtick_2_terminal(terminal, data, tree)?;
14679 }
14680 TerminalKind::CodeBlockEnd4 => {
14681 let terminal = CodeBlockEnd4(id);
14682 self.visit_code_block_end_4_terminal(terminal, data, tree)?;
14683 }
14684 TerminalKind::Backtick3 => {
14685 let terminal = Backtick3(id);
14686 self.visit_backtick_3_terminal(terminal, data, tree)?;
14687 }
14688 TerminalKind::CodeBlockEnd5 => {
14689 let terminal = CodeBlockEnd5(id);
14690 self.visit_code_block_end_5_terminal(terminal, data, tree)?;
14691 }
14692 TerminalKind::Backtick4 => {
14693 let terminal = Backtick4(id);
14694 self.visit_backtick_4_terminal(terminal, data, tree)?;
14695 }
14696 TerminalKind::CodeBlockEnd6 => {
14697 let terminal = CodeBlockEnd6(id);
14698 self.visit_code_block_end_6_terminal(terminal, data, tree)?;
14699 }
14700 TerminalKind::Backtick5 => {
14701 let terminal = Backtick5(id);
14702 self.visit_backtick_5_terminal(terminal, data, tree)?;
14703 }
14704 TerminalKind::NoBacktick => {
14705 let terminal = NoBacktick(id);
14706 self.visit_no_backtick_terminal(terminal, data, tree)?;
14707 }
14708 TerminalKind::LitStr3End => {
14709 let terminal = LitStr3End(id);
14710 self.visit_lit_str_3_end_terminal(terminal, data, tree)?;
14711 }
14712 TerminalKind::LitStr2End => {
14713 let terminal = LitStr2End(id);
14714 self.visit_lit_str_2_end_terminal(terminal, data, tree)?;
14715 }
14716 TerminalKind::LitStr1End => {
14717 let terminal = LitStr1End(id);
14718 self.visit_lit_str_1_end_terminal(terminal, data, tree)?;
14719 }
14720 TerminalKind::SQuote => {
14721 let terminal = SQuote(id);
14722 self.visit_s_quote_terminal(terminal, data, tree)?;
14723 }
14724 TerminalKind::NoSQuote => {
14725 let terminal = NoSQuote(id);
14726 self.visit_no_s_quote_terminal(terminal, data, tree)?;
14727 }
14728 TerminalKind::DelimCodeEnd3 => {
14729 let terminal = DelimCodeEnd3(id);
14730 self.visit_delim_code_end_3_terminal(terminal, data, tree)?;
14731 }
14732 TerminalKind::DelimCodeEnd2 => {
14733 let terminal = DelimCodeEnd2(id);
14734 self.visit_delim_code_end_2_terminal(terminal, data, tree)?;
14735 }
14736 TerminalKind::DelimCodeEnd1 => {
14737 let terminal = DelimCodeEnd1(id);
14738 self.visit_delim_code_end_1_terminal(terminal, data, tree)?;
14739 }
14740 TerminalKind::BacktickDelim => {
14741 let terminal = BacktickDelim(id);
14742 self.visit_backtick_delim_terminal(terminal, data, tree)?;
14743 }
14744 TerminalKind::GrammarNewline => {
14745 let terminal = GrammarNewline(id);
14746 self.visit_grammar_newline_terminal(terminal, data, tree)?;
14747 }
14748 TerminalKind::Ws => {
14749 let terminal = Ws(id);
14750 self.visit_ws_terminal(terminal, data, tree)?;
14751 }
14752 TerminalKind::At => {
14753 let terminal = At(id);
14754 self.visit_at_terminal(terminal, data, tree)?;
14755 }
14756 TerminalKind::Dollar => {
14757 let terminal = Dollar(id);
14758 self.visit_dollar_terminal(terminal, data, tree)?;
14759 }
14760 TerminalKind::Dot => {
14761 let terminal = Dot(id);
14762 self.visit_dot_terminal(terminal, data, tree)?;
14763 }
14764 TerminalKind::LBrace => {
14765 let terminal = LBrace(id);
14766 self.visit_l_brace_terminal(terminal, data, tree)?;
14767 }
14768 TerminalKind::RBrace => {
14769 let terminal = RBrace(id);
14770 self.visit_r_brace_terminal(terminal, data, tree)?;
14771 }
14772 TerminalKind::LBracket => {
14773 let terminal = LBracket(id);
14774 self.visit_l_bracket_terminal(terminal, data, tree)?;
14775 }
14776 TerminalKind::RBracket => {
14777 let terminal = RBracket(id);
14778 self.visit_r_bracket_terminal(terminal, data, tree)?;
14779 }
14780 TerminalKind::LParen => {
14781 let terminal = LParen(id);
14782 self.visit_l_paren_terminal(terminal, data, tree)?;
14783 }
14784 TerminalKind::RParen => {
14785 let terminal = RParen(id);
14786 self.visit_r_paren_terminal(terminal, data, tree)?;
14787 }
14788 TerminalKind::NewlineBind => {
14789 let terminal = NewlineBind(id);
14790 self.visit_newline_bind_terminal(terminal, data, tree)?;
14791 }
14792 TerminalKind::Bind => {
14793 let terminal = Bind(id);
14794 self.visit_bind_terminal(terminal, data, tree)?;
14795 }
14796 TerminalKind::Comma => {
14797 let terminal = Comma(id);
14798 self.visit_comma_terminal(terminal, data, tree)?;
14799 }
14800 TerminalKind::Esc => {
14801 let terminal = Esc(id);
14802 self.visit_esc_terminal(terminal, data, tree)?;
14803 }
14804 TerminalKind::NewlineTextStart => {
14805 let terminal = NewlineTextStart(id);
14806 self.visit_newline_text_start_terminal(terminal, data, tree)?;
14807 }
14808 TerminalKind::TextStart => {
14809 let terminal = TextStart(id);
14810 self.visit_text_start_terminal(terminal, data, tree)?;
14811 }
14812 TerminalKind::Ident => {
14813 let terminal = Ident(id);
14814 self.visit_ident_terminal(terminal, data, tree)?;
14815 }
14816 },
14817 }
14818 Ok(())
14819 }
14820}
14821mod private2 {
14822 pub trait Sealed {}
14823}
14824pub trait NodeVisitor: NodeVisitorSuper<Self::Error> {
14825 type Error;
14826 fn visit_node(&mut self, id: CstNodeId, node: CstNode, tree: &Cst) -> Result<(), Self::Error>;
14827}
14828pub trait NodeVisitorSuper<E>: private2::Sealed {
14829 fn visit_node_id(&mut self, id: CstNodeId, tree: &Cst) -> Result<(), E>;
14830 fn visit_node_super(&mut self, id: CstNodeId, node: CstNode, tree: &Cst) -> Result<(), E>;
14831}
14832impl<V: NodeVisitor> private2::Sealed for V {}
14833impl<V: NodeVisitor> NodeVisitorSuper<V::Error> for V {
14834 fn visit_node_id(&mut self, id: CstNodeId, tree: &Cst) -> Result<(), V::Error> {
14835 if let Some(node) = tree.node_data(id) {
14836 self.visit_node(id, node, tree)
14837 } else {
14838 Ok(())
14839 }
14840 }
14841 fn visit_node_super(
14842 &mut self,
14843 id: CstNodeId,
14844 _node: CstNode,
14845 tree: &Cst,
14846 ) -> Result<(), V::Error> {
14847 for child in tree.children(id) {
14848 if let Some(child_node) = tree.node_data(child) {
14849 self.visit_node(child, child_node, tree)?;
14850 }
14851 }
14852 Ok(())
14853 }
14854}
14855pub trait BuiltinTerminalVisitor<E, F: CstFacade> {
14856 fn visit_builtin_new_line_terminal(
14857 &mut self,
14858 terminal: NewLine,
14859 data: TerminalData,
14860 tree: &F,
14861 ) -> Result<(), E>;
14862 fn visit_builtin_whitespace_terminal(
14863 &mut self,
14864 terminal: Whitespace,
14865 data: TerminalData,
14866 tree: &F,
14867 ) -> Result<(), E>;
14868 fn visit_builtin_line_comment_terminal(
14869 &mut self,
14870 terminal: LineComment,
14871 data: TerminalData,
14872 tree: &F,
14873 ) -> Result<(), E>;
14874 fn visit_builtin_block_comment_terminal(
14875 &mut self,
14876 terminal: BlockComment,
14877 data: TerminalData,
14878 tree: &F,
14879 ) -> Result<(), E>;
14880}
14881impl<V: CstVisitor<F>, F: CstFacade> BuiltinTerminalVisitor<V::Error, F> for V {
14882 fn visit_builtin_new_line_terminal(
14883 &mut self,
14884 terminal: NewLine,
14885 data: TerminalData,
14886 tree: &F,
14887 ) -> Result<(), V::Error> {
14888 self.visit_new_line_terminal(terminal, data, tree)
14889 }
14890 fn visit_builtin_whitespace_terminal(
14891 &mut self,
14892 terminal: Whitespace,
14893 data: TerminalData,
14894 tree: &F,
14895 ) -> Result<(), V::Error> {
14896 self.visit_whitespace_terminal(terminal, data, tree)
14897 }
14898 fn visit_builtin_line_comment_terminal(
14899 &mut self,
14900 terminal: LineComment,
14901 data: TerminalData,
14902 tree: &F,
14903 ) -> Result<(), V::Error> {
14904 self.visit_line_comment_terminal(terminal, data, tree)
14905 }
14906 fn visit_builtin_block_comment_terminal(
14907 &mut self,
14908 terminal: BlockComment,
14909 data: TerminalData,
14910 tree: &F,
14911 ) -> Result<(), V::Error> {
14912 self.visit_block_comment_terminal(terminal, data, tree)
14913 }
14914}