graphql.visitor source code

1 module graphql.visitor;
2 
3 import graphql.ast;
4 import graphql.tokenmodule;
5 
6 @safe:
7 
8 class Visitor {
9 
10 	void enter(Document obj) {}
11 	void exit(Document obj) {}
12 
13 	void accept(Document obj) {
14 		enter(obj);
15 		final switch(obj.ruleSelection) {
16 			case DocumentEnum.Defi:
17 				obj.defs.visit(this);
18 				break;
19 		}
20 		exit(obj);
21 	}
22 
23 	void enter(const(Document) obj) {}
24 	void exit(const(Document) obj) {}
25 
26 	void accept(const(Document) obj) {
27 		enter(obj);
28 		final switch(obj.ruleSelection) {
29 			case DocumentEnum.Defi:
30 				obj.defs.visit(this);
31 				break;
32 		}
33 		exit(obj);
34 	}
35 
36 	void enter(Definitions obj) {}
37 	void exit(Definitions obj) {}
38 
39 	void accept(Definitions obj) {
40 		enter(obj);
41 		final switch(obj.ruleSelection) {
42 			case DefinitionsEnum.Def:
43 				obj.def.visit(this);
44 				break;
45 			case DefinitionsEnum.Defs:
46 				obj.def.visit(this);
47 				obj.follow.visit(this);
48 				break;
49 		}
50 		exit(obj);
51 	}
52 
53 	void enter(const(Definitions) obj) {}
54 	void exit(const(Definitions) obj) {}
55 
56 	void accept(const(Definitions) obj) {
57 		enter(obj);
58 		final switch(obj.ruleSelection) {
59 			case DefinitionsEnum.Def:
60 				obj.def.visit(this);
61 				break;
62 			case DefinitionsEnum.Defs:
63 				obj.def.visit(this);
64 				obj.follow.visit(this);
65 				break;
66 		}
67 		exit(obj);
68 	}
69 
70 	void enter(Definition obj) {}
71 	void exit(Definition obj) {}
72 
73 	void accept(Definition obj) {
74 		enter(obj);
75 		final switch(obj.ruleSelection) {
76 			case DefinitionEnum.O:
77 				obj.op.visit(this);
78 				break;
79 			case DefinitionEnum.F:
80 				obj.frag.visit(this);
81 				break;
82 			case DefinitionEnum.T:
83 				obj.type.visit(this);
84 				break;
85 		}
86 		exit(obj);
87 	}
88 
89 	void enter(const(Definition) obj) {}
90 	void exit(const(Definition) obj) {}
91 
92 	void accept(const(Definition) obj) {
93 		enter(obj);
94 		final switch(obj.ruleSelection) {
95 			case DefinitionEnum.O:
96 				obj.op.visit(this);
97 				break;
98 			case DefinitionEnum.F:
99 				obj.frag.visit(this);
100 				break;
101 			case DefinitionEnum.T:
102 				obj.type.visit(this);
103 				break;
104 		}
105 		exit(obj);
106 	}
107 
108 	void enter(OperationDefinition obj) {}
109 	void exit(OperationDefinition obj) {}
110 
111 	void accept(OperationDefinition obj) {
112 		enter(obj);
113 		final switch(obj.ruleSelection) {
114 			case OperationDefinitionEnum.SelSet:
115 				obj.ss.visit(this);
116 				break;
117 			case OperationDefinitionEnum.OT_N_VD:
118 				obj.ot.visit(this);
119 				obj.name.visit(this);
120 				obj.vd.visit(this);
121 				obj.d.visit(this);
122 				obj.ss.visit(this);
123 				break;
124 			case OperationDefinitionEnum.OT_N_V:
125 				obj.ot.visit(this);
126 				obj.name.visit(this);
127 				obj.vd.visit(this);
128 				obj.ss.visit(this);
129 				break;
130 			case OperationDefinitionEnum.OT_N_D:
131 				obj.ot.visit(this);
132 				obj.name.visit(this);
133 				obj.d.visit(this);
134 				obj.ss.visit(this);
135 				break;
136 			case OperationDefinitionEnum.OT_N:
137 				obj.ot.visit(this);
138 				obj.name.visit(this);
139 				obj.ss.visit(this);
140 				break;
141 			case OperationDefinitionEnum.OT_VD:
142 				obj.ot.visit(this);
143 				obj.vd.visit(this);
144 				obj.d.visit(this);
145 				obj.ss.visit(this);
146 				break;
147 			case OperationDefinitionEnum.OT_V:
148 				obj.ot.visit(this);
149 				obj.vd.visit(this);
150 				obj.ss.visit(this);
151 				break;
152 			case OperationDefinitionEnum.OT_D:
153 				obj.ot.visit(this);
154 				obj.d.visit(this);
155 				obj.ss.visit(this);
156 				break;
157 			case OperationDefinitionEnum.OT:
158 				obj.ot.visit(this);
159 				obj.ss.visit(this);
160 				break;
161 		}
162 		exit(obj);
163 	}
164 
165 	void enter(const(OperationDefinition) obj) {}
166 	void exit(const(OperationDefinition) obj) {}
167 
168 	void accept(const(OperationDefinition) obj) {
169 		enter(obj);
170 		final switch(obj.ruleSelection) {
171 			case OperationDefinitionEnum.SelSet:
172 				obj.ss.visit(this);
173 				break;
174 			case OperationDefinitionEnum.OT_N_VD:
175 				obj.ot.visit(this);
176 				obj.name.visit(this);
177 				obj.vd.visit(this);
178 				obj.d.visit(this);
179 				obj.ss.visit(this);
180 				break;
181 			case OperationDefinitionEnum.OT_N_V:
182 				obj.ot.visit(this);
183 				obj.name.visit(this);
184 				obj.vd.visit(this);
185 				obj.ss.visit(this);
186 				break;
187 			case OperationDefinitionEnum.OT_N_D:
188 				obj.ot.visit(this);
189 				obj.name.visit(this);
190 				obj.d.visit(this);
191 				obj.ss.visit(this);
192 				break;
193 			case OperationDefinitionEnum.OT_N:
194 				obj.ot.visit(this);
195 				obj.name.visit(this);
196 				obj.ss.visit(this);
197 				break;
198 			case OperationDefinitionEnum.OT_VD:
199 				obj.ot.visit(this);
200 				obj.vd.visit(this);
201 				obj.d.visit(this);
202 				obj.ss.visit(this);
203 				break;
204 			case OperationDefinitionEnum.OT_V:
205 				obj.ot.visit(this);
206 				obj.vd.visit(this);
207 				obj.ss.visit(this);
208 				break;
209 			case OperationDefinitionEnum.OT_D:
210 				obj.ot.visit(this);
211 				obj.d.visit(this);
212 				obj.ss.visit(this);
213 				break;
214 			case OperationDefinitionEnum.OT:
215 				obj.ot.visit(this);
216 				obj.ss.visit(this);
217 				break;
218 		}
219 		exit(obj);
220 	}
221 
222 	void enter(SelectionSet obj) {}
223 	void exit(SelectionSet obj) {}
224 
225 	void accept(SelectionSet obj) {
226 		enter(obj);
227 		final switch(obj.ruleSelection) {
228 			case SelectionSetEnum.SS:
229 				obj.sel.visit(this);
230 				break;
231 		}
232 		exit(obj);
233 	}
234 
235 	void enter(const(SelectionSet) obj) {}
236 	void exit(const(SelectionSet) obj) {}
237 
238 	void accept(const(SelectionSet) obj) {
239 		enter(obj);
240 		final switch(obj.ruleSelection) {
241 			case SelectionSetEnum.SS:
242 				obj.sel.visit(this);
243 				break;
244 		}
245 		exit(obj);
246 	}
247 
248 	void enter(OperationType obj) {}
249 	void exit(OperationType obj) {}
250 
251 	void accept(OperationType obj) {
252 		enter(obj);
253 		final switch(obj.ruleSelection) {
254 			case OperationTypeEnum.Query:
255 				obj.tok.visit(this);
256 				break;
257 			case OperationTypeEnum.Mutation:
258 				obj.tok.visit(this);
259 				break;
260 			case OperationTypeEnum.Sub:
261 				obj.tok.visit(this);
262 				break;
263 		}
264 		exit(obj);
265 	}
266 
267 	void enter(const(OperationType) obj) {}
268 	void exit(const(OperationType) obj) {}
269 
270 	void accept(const(OperationType) obj) {
271 		enter(obj);
272 		final switch(obj.ruleSelection) {
273 			case OperationTypeEnum.Query:
274 				obj.tok.visit(this);
275 				break;
276 			case OperationTypeEnum.Mutation:
277 				obj.tok.visit(this);
278 				break;
279 			case OperationTypeEnum.Sub:
280 				obj.tok.visit(this);
281 				break;
282 		}
283 		exit(obj);
284 	}
285 
286 	void enter(Selections obj) {}
287 	void exit(Selections obj) {}
288 
289 	void accept(Selections obj) {
290 		enter(obj);
291 		final switch(obj.ruleSelection) {
292 			case SelectionsEnum.Sel:
293 				obj.sel.visit(this);
294 				break;
295 			case SelectionsEnum.Sels:
296 				obj.sel.visit(this);
297 				obj.follow.visit(this);
298 				break;
299 			case SelectionsEnum.Selsc:
300 				obj.sel.visit(this);
301 				obj.follow.visit(this);
302 				break;
303 		}
304 		exit(obj);
305 	}
306 
307 	void enter(const(Selections) obj) {}
308 	void exit(const(Selections) obj) {}
309 
310 	void accept(const(Selections) obj) {
311 		enter(obj);
312 		final switch(obj.ruleSelection) {
313 			case SelectionsEnum.Sel:
314 				obj.sel.visit(this);
315 				break;
316 			case SelectionsEnum.Sels:
317 				obj.sel.visit(this);
318 				obj.follow.visit(this);
319 				break;
320 			case SelectionsEnum.Selsc:
321 				obj.sel.visit(this);
322 				obj.follow.visit(this);
323 				break;
324 		}
325 		exit(obj);
326 	}
327 
328 	void enter(Selection obj) {}
329 	void exit(Selection obj) {}
330 
331 	void accept(Selection obj) {
332 		enter(obj);
333 		final switch(obj.ruleSelection) {
334 			case SelectionEnum.Field:
335 				obj.field.visit(this);
336 				break;
337 			case SelectionEnum.Spread:
338 				obj.frag.visit(this);
339 				break;
340 			case SelectionEnum.IFrag:
341 				obj.ifrag.visit(this);
342 				break;
343 		}
344 		exit(obj);
345 	}
346 
347 	void enter(const(Selection) obj) {}
348 	void exit(const(Selection) obj) {}
349 
350 	void accept(const(Selection) obj) {
351 		enter(obj);
352 		final switch(obj.ruleSelection) {
353 			case SelectionEnum.Field:
354 				obj.field.visit(this);
355 				break;
356 			case SelectionEnum.Spread:
357 				obj.frag.visit(this);
358 				break;
359 			case SelectionEnum.IFrag:
360 				obj.ifrag.visit(this);
361 				break;
362 		}
363 		exit(obj);
364 	}
365 
366 	void enter(FragmentSpread obj) {}
367 	void exit(FragmentSpread obj) {}
368 
369 	void accept(FragmentSpread obj) {
370 		enter(obj);
371 		final switch(obj.ruleSelection) {
372 			case FragmentSpreadEnum.FD:
373 				obj.name.visit(this);
374 				obj.dirs.visit(this);
375 				break;
376 			case FragmentSpreadEnum.F:
377 				obj.name.visit(this);
378 				break;
379 		}
380 		exit(obj);
381 	}
382 
383 	void enter(const(FragmentSpread) obj) {}
384 	void exit(const(FragmentSpread) obj) {}
385 
386 	void accept(const(FragmentSpread) obj) {
387 		enter(obj);
388 		final switch(obj.ruleSelection) {
389 			case FragmentSpreadEnum.FD:
390 				obj.name.visit(this);
391 				obj.dirs.visit(this);
392 				break;
393 			case FragmentSpreadEnum.F:
394 				obj.name.visit(this);
395 				break;
396 		}
397 		exit(obj);
398 	}
399 
400 	void enter(InlineFragment obj) {}
401 	void exit(InlineFragment obj) {}
402 
403 	void accept(InlineFragment obj) {
404 		enter(obj);
405 		final switch(obj.ruleSelection) {
406 			case InlineFragmentEnum.TDS:
407 				obj.tc.visit(this);
408 				obj.dirs.visit(this);
409 				obj.ss.visit(this);
410 				break;
411 			case InlineFragmentEnum.TS:
412 				obj.tc.visit(this);
413 				obj.ss.visit(this);
414 				break;
415 			case InlineFragmentEnum.DS:
416 				obj.dirs.visit(this);
417 				obj.ss.visit(this);
418 				break;
419 			case InlineFragmentEnum.S:
420 				obj.ss.visit(this);
421 				break;
422 		}
423 		exit(obj);
424 	}
425 
426 	void enter(const(InlineFragment) obj) {}
427 	void exit(const(InlineFragment) obj) {}
428 
429 	void accept(const(InlineFragment) obj) {
430 		enter(obj);
431 		final switch(obj.ruleSelection) {
432 			case InlineFragmentEnum.TDS:
433 				obj.tc.visit(this);
434 				obj.dirs.visit(this);
435 				obj.ss.visit(this);
436 				break;
437 			case InlineFragmentEnum.TS:
438 				obj.tc.visit(this);
439 				obj.ss.visit(this);
440 				break;
441 			case InlineFragmentEnum.DS:
442 				obj.dirs.visit(this);
443 				obj.ss.visit(this);
444 				break;
445 			case InlineFragmentEnum.S:
446 				obj.ss.visit(this);
447 				break;
448 		}
449 		exit(obj);
450 	}
451 
452 	void enter(Field obj) {}
453 	void exit(Field obj) {}
454 
455 	void accept(Field obj) {
456 		enter(obj);
457 		final switch(obj.ruleSelection) {
458 			case FieldEnum.FADS:
459 				obj.name.visit(this);
460 				obj.args.visit(this);
461 				obj.dirs.visit(this);
462 				obj.ss.visit(this);
463 				break;
464 			case FieldEnum.FAS:
465 				obj.name.visit(this);
466 				obj.args.visit(this);
467 				obj.ss.visit(this);
468 				break;
469 			case FieldEnum.FAD:
470 				obj.name.visit(this);
471 				obj.args.visit(this);
472 				obj.dirs.visit(this);
473 				break;
474 			case FieldEnum.FDS:
475 				obj.name.visit(this);
476 				obj.dirs.visit(this);
477 				obj.ss.visit(this);
478 				break;
479 			case FieldEnum.FS:
480 				obj.name.visit(this);
481 				obj.ss.visit(this);
482 				break;
483 			case FieldEnum.FD:
484 				obj.name.visit(this);
485 				obj.dirs.visit(this);
486 				break;
487 			case FieldEnum.FA:
488 				obj.name.visit(this);
489 				obj.args.visit(this);
490 				break;
491 			case FieldEnum.F:
492 				obj.name.visit(this);
493 				break;
494 		}
495 		exit(obj);
496 	}
497 
498 	void enter(const(Field) obj) {}
499 	void exit(const(Field) obj) {}
500 
501 	void accept(const(Field) obj) {
502 		enter(obj);
503 		final switch(obj.ruleSelection) {
504 			case FieldEnum.FADS:
505 				obj.name.visit(this);
506 				obj.args.visit(this);
507 				obj.dirs.visit(this);
508 				obj.ss.visit(this);
509 				break;
510 			case FieldEnum.FAS:
511 				obj.name.visit(this);
512 				obj.args.visit(this);
513 				obj.ss.visit(this);
514 				break;
515 			case FieldEnum.FAD:
516 				obj.name.visit(this);
517 				obj.args.visit(this);
518 				obj.dirs.visit(this);
519 				break;
520 			case FieldEnum.FDS:
521 				obj.name.visit(this);
522 				obj.dirs.visit(this);
523 				obj.ss.visit(this);
524 				break;
525 			case FieldEnum.FS:
526 				obj.name.visit(this);
527 				obj.ss.visit(this);
528 				break;
529 			case FieldEnum.FD:
530 				obj.name.visit(this);
531 				obj.dirs.visit(this);
532 				break;
533 			case FieldEnum.FA:
534 				obj.name.visit(this);
535 				obj.args.visit(this);
536 				break;
537 			case FieldEnum.F:
538 				obj.name.visit(this);
539 				break;
540 		}
541 		exit(obj);
542 	}
543 
544 	void enter(FieldName obj) {}
545 	void exit(FieldName obj) {}
546 
547 	void accept(FieldName obj) {
548 		enter(obj);
549 		final switch(obj.ruleSelection) {
550 			case FieldNameEnum.A:
551 				obj.name.visit(this);
552 				obj.aka.visit(this);
553 				break;
554 			case FieldNameEnum.N:
555 				obj.name.visit(this);
556 				break;
557 		}
558 		exit(obj);
559 	}
560 
561 	void enter(const(FieldName) obj) {}
562 	void exit(const(FieldName) obj) {}
563 
564 	void accept(const(FieldName) obj) {
565 		enter(obj);
566 		final switch(obj.ruleSelection) {
567 			case FieldNameEnum.A:
568 				obj.name.visit(this);
569 				obj.aka.visit(this);
570 				break;
571 			case FieldNameEnum.N:
572 				obj.name.visit(this);
573 				break;
574 		}
575 		exit(obj);
576 	}
577 
578 	void enter(Arguments obj) {}
579 	void exit(Arguments obj) {}
580 
581 	void accept(Arguments obj) {
582 		enter(obj);
583 		final switch(obj.ruleSelection) {
584 			case ArgumentsEnum.List:
585 				obj.arg.visit(this);
586 				break;
587 			case ArgumentsEnum.Empty:
588 				break;
589 		}
590 		exit(obj);
591 	}
592 
593 	void enter(const(Arguments) obj) {}
594 	void exit(const(Arguments) obj) {}
595 
596 	void accept(const(Arguments) obj) {
597 		enter(obj);
598 		final switch(obj.ruleSelection) {
599 			case ArgumentsEnum.List:
600 				obj.arg.visit(this);
601 				break;
602 			case ArgumentsEnum.Empty:
603 				break;
604 		}
605 		exit(obj);
606 	}
607 
608 	void enter(ArgumentList obj) {}
609 	void exit(ArgumentList obj) {}
610 
611 	void accept(ArgumentList obj) {
612 		enter(obj);
613 		final switch(obj.ruleSelection) {
614 			case ArgumentListEnum.A:
615 				obj.arg.visit(this);
616 				break;
617 			case ArgumentListEnum.ACS:
618 				obj.arg.visit(this);
619 				obj.follow.visit(this);
620 				break;
621 			case ArgumentListEnum.AS:
622 				obj.arg.visit(this);
623 				obj.follow.visit(this);
624 				break;
625 		}
626 		exit(obj);
627 	}
628 
629 	void enter(const(ArgumentList) obj) {}
630 	void exit(const(ArgumentList) obj) {}
631 
632 	void accept(const(ArgumentList) obj) {
633 		enter(obj);
634 		final switch(obj.ruleSelection) {
635 			case ArgumentListEnum.A:
636 				obj.arg.visit(this);
637 				break;
638 			case ArgumentListEnum.ACS:
639 				obj.arg.visit(this);
640 				obj.follow.visit(this);
641 				break;
642 			case ArgumentListEnum.AS:
643 				obj.arg.visit(this);
644 				obj.follow.visit(this);
645 				break;
646 		}
647 		exit(obj);
648 	}
649 
650 	void enter(Argument obj) {}
651 	void exit(Argument obj) {}
652 
653 	void accept(Argument obj) {
654 		enter(obj);
655 		final switch(obj.ruleSelection) {
656 			case ArgumentEnum.Name:
657 				obj.name.visit(this);
658 				obj.vv.visit(this);
659 				break;
660 		}
661 		exit(obj);
662 	}
663 
664 	void enter(const(Argument) obj) {}
665 	void exit(const(Argument) obj) {}
666 
667 	void accept(const(Argument) obj) {
668 		enter(obj);
669 		final switch(obj.ruleSelection) {
670 			case ArgumentEnum.Name:
671 				obj.name.visit(this);
672 				obj.vv.visit(this);
673 				break;
674 		}
675 		exit(obj);
676 	}
677 
678 	void enter(FragmentDefinition obj) {}
679 	void exit(FragmentDefinition obj) {}
680 
681 	void accept(FragmentDefinition obj) {
682 		enter(obj);
683 		final switch(obj.ruleSelection) {
684 			case FragmentDefinitionEnum.FTDS:
685 				obj.name.visit(this);
686 				obj.tc.visit(this);
687 				obj.dirs.visit(this);
688 				obj.ss.visit(this);
689 				break;
690 			case FragmentDefinitionEnum.FTS:
691 				obj.name.visit(this);
692 				obj.tc.visit(this);
693 				obj.ss.visit(this);
694 				break;
695 		}
696 		exit(obj);
697 	}
698 
699 	void enter(const(FragmentDefinition) obj) {}
700 	void exit(const(FragmentDefinition) obj) {}
701 
702 	void accept(const(FragmentDefinition) obj) {
703 		enter(obj);
704 		final switch(obj.ruleSelection) {
705 			case FragmentDefinitionEnum.FTDS:
706 				obj.name.visit(this);
707 				obj.tc.visit(this);
708 				obj.dirs.visit(this);
709 				obj.ss.visit(this);
710 				break;
711 			case FragmentDefinitionEnum.FTS:
712 				obj.name.visit(this);
713 				obj.tc.visit(this);
714 				obj.ss.visit(this);
715 				break;
716 		}
717 		exit(obj);
718 	}
719 
720 	void enter(Directives obj) {}
721 	void exit(Directives obj) {}
722 
723 	void accept(Directives obj) {
724 		enter(obj);
725 		final switch(obj.ruleSelection) {
726 			case DirectivesEnum.Dir:
727 				obj.dir.visit(this);
728 				break;
729 			case DirectivesEnum.Dirs:
730 				obj.dir.visit(this);
731 				obj.follow.visit(this);
732 				break;
733 		}
734 		exit(obj);
735 	}
736 
737 	void enter(const(Directives) obj) {}
738 	void exit(const(Directives) obj) {}
739 
740 	void accept(const(Directives) obj) {
741 		enter(obj);
742 		final switch(obj.ruleSelection) {
743 			case DirectivesEnum.Dir:
744 				obj.dir.visit(this);
745 				break;
746 			case DirectivesEnum.Dirs:
747 				obj.dir.visit(this);
748 				obj.follow.visit(this);
749 				break;
750 		}
751 		exit(obj);
752 	}
753 
754 	void enter(Directive obj) {}
755 	void exit(Directive obj) {}
756 
757 	void accept(Directive obj) {
758 		enter(obj);
759 		final switch(obj.ruleSelection) {
760 			case DirectiveEnum.NArg:
761 				obj.name.visit(this);
762 				obj.arg.visit(this);
763 				break;
764 			case DirectiveEnum.N:
765 				obj.name.visit(this);
766 				break;
767 		}
768 		exit(obj);
769 	}
770 
771 	void enter(const(Directive) obj) {}
772 	void exit(const(Directive) obj) {}
773 
774 	void accept(const(Directive) obj) {
775 		enter(obj);
776 		final switch(obj.ruleSelection) {
777 			case DirectiveEnum.NArg:
778 				obj.name.visit(this);
779 				obj.arg.visit(this);
780 				break;
781 			case DirectiveEnum.N:
782 				obj.name.visit(this);
783 				break;
784 		}
785 		exit(obj);
786 	}
787 
788 	void enter(VariableDefinitions obj) {}
789 	void exit(VariableDefinitions obj) {}
790 
791 	void accept(VariableDefinitions obj) {
792 		enter(obj);
793 		final switch(obj.ruleSelection) {
794 			case VariableDefinitionsEnum.Empty:
795 				break;
796 			case VariableDefinitionsEnum.Vars:
797 				obj.vars.visit(this);
798 				break;
799 		}
800 		exit(obj);
801 	}
802 
803 	void enter(const(VariableDefinitions) obj) {}
804 	void exit(const(VariableDefinitions) obj) {}
805 
806 	void accept(const(VariableDefinitions) obj) {
807 		enter(obj);
808 		final switch(obj.ruleSelection) {
809 			case VariableDefinitionsEnum.Empty:
810 				break;
811 			case VariableDefinitionsEnum.Vars:
812 				obj.vars.visit(this);
813 				break;
814 		}
815 		exit(obj);
816 	}
817 
818 	void enter(VariableDefinitionList obj) {}
819 	void exit(VariableDefinitionList obj) {}
820 
821 	void accept(VariableDefinitionList obj) {
822 		enter(obj);
823 		final switch(obj.ruleSelection) {
824 			case VariableDefinitionListEnum.V:
825 				obj.var.visit(this);
826 				break;
827 			case VariableDefinitionListEnum.VCF:
828 				obj.var.visit(this);
829 				obj.follow.visit(this);
830 				break;
831 			case VariableDefinitionListEnum.VF:
832 				obj.var.visit(this);
833 				obj.follow.visit(this);
834 				break;
835 		}
836 		exit(obj);
837 	}
838 
839 	void enter(const(VariableDefinitionList) obj) {}
840 	void exit(const(VariableDefinitionList) obj) {}
841 
842 	void accept(const(VariableDefinitionList) obj) {
843 		enter(obj);
844 		final switch(obj.ruleSelection) {
845 			case VariableDefinitionListEnum.V:
846 				obj.var.visit(this);
847 				break;
848 			case VariableDefinitionListEnum.VCF:
849 				obj.var.visit(this);
850 				obj.follow.visit(this);
851 				break;
852 			case VariableDefinitionListEnum.VF:
853 				obj.var.visit(this);
854 				obj.follow.visit(this);
855 				break;
856 		}
857 		exit(obj);
858 	}
859 
860 	void enter(VariableDefinition obj) {}
861 	void exit(VariableDefinition obj) {}
862 
863 	void accept(VariableDefinition obj) {
864 		enter(obj);
865 		final switch(obj.ruleSelection) {
866 			case VariableDefinitionEnum.VarD:
867 				obj.type.visit(this);
868 				obj.dvalue.visit(this);
869 				break;
870 			case VariableDefinitionEnum.Var:
871 				obj.type.visit(this);
872 				break;
873 		}
874 		exit(obj);
875 	}
876 
877 	void enter(const(VariableDefinition) obj) {}
878 	void exit(const(VariableDefinition) obj) {}
879 
880 	void accept(const(VariableDefinition) obj) {
881 		enter(obj);
882 		final switch(obj.ruleSelection) {
883 			case VariableDefinitionEnum.VarD:
884 				obj.type.visit(this);
885 				obj.dvalue.visit(this);
886 				break;
887 			case VariableDefinitionEnum.Var:
888 				obj.type.visit(this);
889 				break;
890 		}
891 		exit(obj);
892 	}
893 
894 	void enter(Variable obj) {}
895 	void exit(Variable obj) {}
896 
897 	void accept(Variable obj) {
898 		enter(obj);
899 		final switch(obj.ruleSelection) {
900 			case VariableEnum.Var:
901 				obj.name.visit(this);
902 				break;
903 		}
904 		exit(obj);
905 	}
906 
907 	void enter(const(Variable) obj) {}
908 	void exit(const(Variable) obj) {}
909 
910 	void accept(const(Variable) obj) {
911 		enter(obj);
912 		final switch(obj.ruleSelection) {
913 			case VariableEnum.Var:
914 				obj.name.visit(this);
915 				break;
916 		}
917 		exit(obj);
918 	}
919 
920 	void enter(DefaultValue obj) {}
921 	void exit(DefaultValue obj) {}
922 
923 	void accept(DefaultValue obj) {
924 		enter(obj);
925 		final switch(obj.ruleSelection) {
926 			case DefaultValueEnum.DV:
927 				obj.value.visit(this);
928 				break;
929 		}
930 		exit(obj);
931 	}
932 
933 	void enter(const(DefaultValue) obj) {}
934 	void exit(const(DefaultValue) obj) {}
935 
936 	void accept(const(DefaultValue) obj) {
937 		enter(obj);
938 		final switch(obj.ruleSelection) {
939 			case DefaultValueEnum.DV:
940 				obj.value.visit(this);
941 				break;
942 		}
943 		exit(obj);
944 	}
945 
946 	void enter(ValueOrVariable obj) {}
947 	void exit(ValueOrVariable obj) {}
948 
949 	void accept(ValueOrVariable obj) {
950 		enter(obj);
951 		final switch(obj.ruleSelection) {
952 			case ValueOrVariableEnum.Val:
953 				obj.val.visit(this);
954 				break;
955 			case ValueOrVariableEnum.Var:
956 				obj.var.visit(this);
957 				break;
958 		}
959 		exit(obj);
960 	}
961 
962 	void enter(const(ValueOrVariable) obj) {}
963 	void exit(const(ValueOrVariable) obj) {}
964 
965 	void accept(const(ValueOrVariable) obj) {
966 		enter(obj);
967 		final switch(obj.ruleSelection) {
968 			case ValueOrVariableEnum.Val:
969 				obj.val.visit(this);
970 				break;
971 			case ValueOrVariableEnum.Var:
972 				obj.var.visit(this);
973 				break;
974 		}
975 		exit(obj);
976 	}
977 
978 	void enter(Value obj) {}
979 	void exit(Value obj) {}
980 
981 	void accept(Value obj) {
982 		enter(obj);
983 		final switch(obj.ruleSelection) {
984 			case ValueEnum.STR:
985 				obj.tok.visit(this);
986 				break;
987 			case ValueEnum.INT:
988 				obj.tok.visit(this);
989 				break;
990 			case ValueEnum.FLOAT:
991 				obj.tok.visit(this);
992 				break;
993 			case ValueEnum.T:
994 				obj.tok.visit(this);
995 				break;
996 			case ValueEnum.F:
997 				obj.tok.visit(this);
998 				break;
999 			case ValueEnum.ARR:
1000 				obj.arr.visit(this);
1001 				break;
1002 			case ValueEnum.O:
1003 				obj.obj.visit(this);
1004 				break;
1005 			case ValueEnum.E:
1006 				obj.tok.visit(this);
1007 				break;
1008 		}
1009 		exit(obj);
1010 	}
1011 
1012 	void enter(const(Value) obj) {}
1013 	void exit(const(Value) obj) {}
1014 
1015 	void accept(const(Value) obj) {
1016 		enter(obj);
1017 		final switch(obj.ruleSelection) {
1018 			case ValueEnum.STR:
1019 				obj.tok.visit(this);
1020 				break;
1021 			case ValueEnum.INT:
1022 				obj.tok.visit(this);
1023 				break;
1024 			case ValueEnum.FLOAT:
1025 				obj.tok.visit(this);
1026 				break;
1027 			case ValueEnum.T:
1028 				obj.tok.visit(this);
1029 				break;
1030 			case ValueEnum.F:
1031 				obj.tok.visit(this);
1032 				break;
1033 			case ValueEnum.ARR:
1034 				obj.arr.visit(this);
1035 				break;
1036 			case ValueEnum.O:
1037 				obj.obj.visit(this);
1038 				break;
1039 			case ValueEnum.E:
1040 				obj.tok.visit(this);
1041 				break;
1042 		}
1043 		exit(obj);
1044 	}
1045 
1046 	void enter(Type obj) {}
1047 	void exit(Type obj) {}
1048 
1049 	void accept(Type obj) {
1050 		enter(obj);
1051 		final switch(obj.ruleSelection) {
1052 			case TypeEnum.TN:
1053 				obj.tname.visit(this);
1054 				break;
1055 			case TypeEnum.LN:
1056 				obj.list.visit(this);
1057 				break;
1058 			case TypeEnum.T:
1059 				obj.tname.visit(this);
1060 				break;
1061 			case TypeEnum.L:
1062 				obj.list.visit(this);
1063 				break;
1064 		}
1065 		exit(obj);
1066 	}
1067 
1068 	void enter(const(Type) obj) {}
1069 	void exit(const(Type) obj) {}
1070 
1071 	void accept(const(Type) obj) {
1072 		enter(obj);
1073 		final switch(obj.ruleSelection) {
1074 			case TypeEnum.TN:
1075 				obj.tname.visit(this);
1076 				break;
1077 			case TypeEnum.LN:
1078 				obj.list.visit(this);
1079 				break;
1080 			case TypeEnum.T:
1081 				obj.tname.visit(this);
1082 				break;
1083 			case TypeEnum.L:
1084 				obj.list.visit(this);
1085 				break;
1086 		}
1087 		exit(obj);
1088 	}
1089 
1090 	void enter(ListType obj) {}
1091 	void exit(ListType obj) {}
1092 
1093 	void accept(ListType obj) {
1094 		enter(obj);
1095 		final switch(obj.ruleSelection) {
1096 			case ListTypeEnum.T:
1097 				obj.type.visit(this);
1098 				break;
1099 		}
1100 		exit(obj);
1101 	}
1102 
1103 	void enter(const(ListType) obj) {}
1104 	void exit(const(ListType) obj) {}
1105 
1106 	void accept(const(ListType) obj) {
1107 		enter(obj);
1108 		final switch(obj.ruleSelection) {
1109 			case ListTypeEnum.T:
1110 				obj.type.visit(this);
1111 				break;
1112 		}
1113 		exit(obj);
1114 	}
1115 
1116 	void enter(Values obj) {}
1117 	void exit(Values obj) {}
1118 
1119 	void accept(Values obj) {
1120 		enter(obj);
1121 		final switch(obj.ruleSelection) {
1122 			case ValuesEnum.Val:
1123 				obj.val.visit(this);
1124 				break;
1125 			case ValuesEnum.Vals:
1126 				obj.val.visit(this);
1127 				obj.follow.visit(this);
1128 				break;
1129 		}
1130 		exit(obj);
1131 	}
1132 
1133 	void enter(const(Values) obj) {}
1134 	void exit(const(Values) obj) {}
1135 
1136 	void accept(const(Values) obj) {
1137 		enter(obj);
1138 		final switch(obj.ruleSelection) {
1139 			case ValuesEnum.Val:
1140 				obj.val.visit(this);
1141 				break;
1142 			case ValuesEnum.Vals:
1143 				obj.val.visit(this);
1144 				obj.follow.visit(this);
1145 				break;
1146 		}
1147 		exit(obj);
1148 	}
1149 
1150 	void enter(Array obj) {}
1151 	void exit(Array obj) {}
1152 
1153 	void accept(Array obj) {
1154 		enter(obj);
1155 		final switch(obj.ruleSelection) {
1156 			case ArrayEnum.Empty:
1157 				break;
1158 			case ArrayEnum.Value:
1159 				obj.vals.visit(this);
1160 				break;
1161 		}
1162 		exit(obj);
1163 	}
1164 
1165 	void enter(const(Array) obj) {}
1166 	void exit(const(Array) obj) {}
1167 
1168 	void accept(const(Array) obj) {
1169 		enter(obj);
1170 		final switch(obj.ruleSelection) {
1171 			case ArrayEnum.Empty:
1172 				break;
1173 			case ArrayEnum.Value:
1174 				obj.vals.visit(this);
1175 				break;
1176 		}
1177 		exit(obj);
1178 	}
1179 
1180 	void enter(ObjectValues obj) {}
1181 	void exit(ObjectValues obj) {}
1182 
1183 	void accept(ObjectValues obj) {
1184 		enter(obj);
1185 		final switch(obj.ruleSelection) {
1186 			case ObjectValuesEnum.V:
1187 				obj.name.visit(this);
1188 				obj.val.visit(this);
1189 				break;
1190 			case ObjectValuesEnum.Vsc:
1191 				obj.name.visit(this);
1192 				obj.val.visit(this);
1193 				obj.follow.visit(this);
1194 				break;
1195 			case ObjectValuesEnum.Vs:
1196 				obj.name.visit(this);
1197 				obj.val.visit(this);
1198 				obj.follow.visit(this);
1199 				break;
1200 		}
1201 		exit(obj);
1202 	}
1203 
1204 	void enter(const(ObjectValues) obj) {}
1205 	void exit(const(ObjectValues) obj) {}
1206 
1207 	void accept(const(ObjectValues) obj) {
1208 		enter(obj);
1209 		final switch(obj.ruleSelection) {
1210 			case ObjectValuesEnum.V:
1211 				obj.name.visit(this);
1212 				obj.val.visit(this);
1213 				break;
1214 			case ObjectValuesEnum.Vsc:
1215 				obj.name.visit(this);
1216 				obj.val.visit(this);
1217 				obj.follow.visit(this);
1218 				break;
1219 			case ObjectValuesEnum.Vs:
1220 				obj.name.visit(this);
1221 				obj.val.visit(this);
1222 				obj.follow.visit(this);
1223 				break;
1224 		}
1225 		exit(obj);
1226 	}
1227 
1228 	void enter(ObjectType obj) {}
1229 	void exit(ObjectType obj) {}
1230 
1231 	void accept(ObjectType obj) {
1232 		enter(obj);
1233 		final switch(obj.ruleSelection) {
1234 			case ObjectTypeEnum.Var:
1235 				obj.vals.visit(this);
1236 				break;
1237 		}
1238 		exit(obj);
1239 	}
1240 
1241 	void enter(const(ObjectType) obj) {}
1242 	void exit(const(ObjectType) obj) {}
1243 
1244 	void accept(const(ObjectType) obj) {
1245 		enter(obj);
1246 		final switch(obj.ruleSelection) {
1247 			case ObjectTypeEnum.Var:
1248 				obj.vals.visit(this);
1249 				break;
1250 		}
1251 		exit(obj);
1252 	}
1253 
1254 	void enter(TypeSystemDefinition obj) {}
1255 	void exit(TypeSystemDefinition obj) {}
1256 
1257 	void accept(TypeSystemDefinition obj) {
1258 		enter(obj);
1259 		final switch(obj.ruleSelection) {
1260 			case TypeSystemDefinitionEnum.S:
1261 				obj.sch.visit(this);
1262 				break;
1263 			case TypeSystemDefinitionEnum.T:
1264 				obj.td.visit(this);
1265 				break;
1266 			case TypeSystemDefinitionEnum.TE:
1267 				obj.ted.visit(this);
1268 				break;
1269 			case TypeSystemDefinitionEnum.D:
1270 				obj.dd.visit(this);
1271 				break;
1272 		}
1273 		exit(obj);
1274 	}
1275 
1276 	void enter(const(TypeSystemDefinition) obj) {}
1277 	void exit(const(TypeSystemDefinition) obj) {}
1278 
1279 	void accept(const(TypeSystemDefinition) obj) {
1280 		enter(obj);
1281 		final switch(obj.ruleSelection) {
1282 			case TypeSystemDefinitionEnum.S:
1283 				obj.sch.visit(this);
1284 				break;
1285 			case TypeSystemDefinitionEnum.T:
1286 				obj.td.visit(this);
1287 				break;
1288 			case TypeSystemDefinitionEnum.TE:
1289 				obj.ted.visit(this);
1290 				break;
1291 			case TypeSystemDefinitionEnum.D:
1292 				obj.dd.visit(this);
1293 				break;
1294 		}
1295 		exit(obj);
1296 	}
1297 
1298 	void enter(TypeDefinition obj) {}
1299 	void exit(TypeDefinition obj) {}
1300 
1301 	void accept(TypeDefinition obj) {
1302 		enter(obj);
1303 		final switch(obj.ruleSelection) {
1304 			case TypeDefinitionEnum.S:
1305 				obj.std.visit(this);
1306 				break;
1307 			case TypeDefinitionEnum.O:
1308 				obj.otd.visit(this);
1309 				break;
1310 			case TypeDefinitionEnum.I:
1311 				obj.itd.visit(this);
1312 				break;
1313 			case TypeDefinitionEnum.U:
1314 				obj.utd.visit(this);
1315 				break;
1316 			case TypeDefinitionEnum.E:
1317 				obj.etd.visit(this);
1318 				break;
1319 			case TypeDefinitionEnum.IO:
1320 				obj.iod.visit(this);
1321 				break;
1322 		}
1323 		exit(obj);
1324 	}
1325 
1326 	void enter(const(TypeDefinition) obj) {}
1327 	void exit(const(TypeDefinition) obj) {}
1328 
1329 	void accept(const(TypeDefinition) obj) {
1330 		enter(obj);
1331 		final switch(obj.ruleSelection) {
1332 			case TypeDefinitionEnum.S:
1333 				obj.std.visit(this);
1334 				break;
1335 			case TypeDefinitionEnum.O:
1336 				obj.otd.visit(this);
1337 				break;
1338 			case TypeDefinitionEnum.I:
1339 				obj.itd.visit(this);
1340 				break;
1341 			case TypeDefinitionEnum.U:
1342 				obj.utd.visit(this);
1343 				break;
1344 			case TypeDefinitionEnum.E:
1345 				obj.etd.visit(this);
1346 				break;
1347 			case TypeDefinitionEnum.IO:
1348 				obj.iod.visit(this);
1349 				break;
1350 		}
1351 		exit(obj);
1352 	}
1353 
1354 	void enter(SchemaDefinition obj) {}
1355 	void exit(SchemaDefinition obj) {}
1356 
1357 	void accept(SchemaDefinition obj) {
1358 		enter(obj);
1359 		final switch(obj.ruleSelection) {
1360 			case SchemaDefinitionEnum.DO:
1361 				obj.dir.visit(this);
1362 				obj.otds.visit(this);
1363 				break;
1364 			case SchemaDefinitionEnum.O:
1365 				obj.otds.visit(this);
1366 				break;
1367 		}
1368 		exit(obj);
1369 	}
1370 
1371 	void enter(const(SchemaDefinition) obj) {}
1372 	void exit(const(SchemaDefinition) obj) {}
1373 
1374 	void accept(const(SchemaDefinition) obj) {
1375 		enter(obj);
1376 		final switch(obj.ruleSelection) {
1377 			case SchemaDefinitionEnum.DO:
1378 				obj.dir.visit(this);
1379 				obj.otds.visit(this);
1380 				break;
1381 			case SchemaDefinitionEnum.O:
1382 				obj.otds.visit(this);
1383 				break;
1384 		}
1385 		exit(obj);
1386 	}
1387 
1388 	void enter(OperationTypeDefinitions obj) {}
1389 	void exit(OperationTypeDefinitions obj) {}
1390 
1391 	void accept(OperationTypeDefinitions obj) {
1392 		enter(obj);
1393 		final switch(obj.ruleSelection) {
1394 			case OperationTypeDefinitionsEnum.O:
1395 				obj.otd.visit(this);
1396 				break;
1397 			case OperationTypeDefinitionsEnum.OCS:
1398 				obj.otd.visit(this);
1399 				obj.follow.visit(this);
1400 				break;
1401 			case OperationTypeDefinitionsEnum.OS:
1402 				obj.otd.visit(this);
1403 				obj.follow.visit(this);
1404 				break;
1405 		}
1406 		exit(obj);
1407 	}
1408 
1409 	void enter(const(OperationTypeDefinitions) obj) {}
1410 	void exit(const(OperationTypeDefinitions) obj) {}
1411 
1412 	void accept(const(OperationTypeDefinitions) obj) {
1413 		enter(obj);
1414 		final switch(obj.ruleSelection) {
1415 			case OperationTypeDefinitionsEnum.O:
1416 				obj.otd.visit(this);
1417 				break;
1418 			case OperationTypeDefinitionsEnum.OCS:
1419 				obj.otd.visit(this);
1420 				obj.follow.visit(this);
1421 				break;
1422 			case OperationTypeDefinitionsEnum.OS:
1423 				obj.otd.visit(this);
1424 				obj.follow.visit(this);
1425 				break;
1426 		}
1427 		exit(obj);
1428 	}
1429 
1430 	void enter(OperationTypeDefinition obj) {}
1431 	void exit(OperationTypeDefinition obj) {}
1432 
1433 	void accept(OperationTypeDefinition obj) {
1434 		enter(obj);
1435 		final switch(obj.ruleSelection) {
1436 			case OperationTypeDefinitionEnum.O:
1437 				obj.ot.visit(this);
1438 				obj.nt.visit(this);
1439 				break;
1440 		}
1441 		exit(obj);
1442 	}
1443 
1444 	void enter(const(OperationTypeDefinition) obj) {}
1445 	void exit(const(OperationTypeDefinition) obj) {}
1446 
1447 	void accept(const(OperationTypeDefinition) obj) {
1448 		enter(obj);
1449 		final switch(obj.ruleSelection) {
1450 			case OperationTypeDefinitionEnum.O:
1451 				obj.ot.visit(this);
1452 				obj.nt.visit(this);
1453 				break;
1454 		}
1455 		exit(obj);
1456 	}
1457 
1458 	void enter(ScalarTypeDefinition obj) {}
1459 	void exit(ScalarTypeDefinition obj) {}
1460 
1461 	void accept(ScalarTypeDefinition obj) {
1462 		enter(obj);
1463 		final switch(obj.ruleSelection) {
1464 			case ScalarTypeDefinitionEnum.D:
1465 				obj.name.visit(this);
1466 				obj.dir.visit(this);
1467 				break;
1468 			case ScalarTypeDefinitionEnum.S:
1469 				obj.name.visit(this);
1470 				break;
1471 		}
1472 		exit(obj);
1473 	}
1474 
1475 	void enter(const(ScalarTypeDefinition) obj) {}
1476 	void exit(const(ScalarTypeDefinition) obj) {}
1477 
1478 	void accept(const(ScalarTypeDefinition) obj) {
1479 		enter(obj);
1480 		final switch(obj.ruleSelection) {
1481 			case ScalarTypeDefinitionEnum.D:
1482 				obj.name.visit(this);
1483 				obj.dir.visit(this);
1484 				break;
1485 			case ScalarTypeDefinitionEnum.S:
1486 				obj.name.visit(this);
1487 				break;
1488 		}
1489 		exit(obj);
1490 	}
1491 
1492 	void enter(ObjectTypeDefinition obj) {}
1493 	void exit(ObjectTypeDefinition obj) {}
1494 
1495 	void accept(ObjectTypeDefinition obj) {
1496 		enter(obj);
1497 		final switch(obj.ruleSelection) {
1498 			case ObjectTypeDefinitionEnum.ID:
1499 				obj.name.visit(this);
1500 				obj.ii.visit(this);
1501 				obj.dir.visit(this);
1502 				obj.fds.visit(this);
1503 				break;
1504 			case ObjectTypeDefinitionEnum.I:
1505 				obj.name.visit(this);
1506 				obj.ii.visit(this);
1507 				obj.fds.visit(this);
1508 				break;
1509 			case ObjectTypeDefinitionEnum.D:
1510 				obj.name.visit(this);
1511 				obj.dir.visit(this);
1512 				obj.fds.visit(this);
1513 				break;
1514 			case ObjectTypeDefinitionEnum.F:
1515 				obj.name.visit(this);
1516 				obj.fds.visit(this);
1517 				break;
1518 		}
1519 		exit(obj);
1520 	}
1521 
1522 	void enter(const(ObjectTypeDefinition) obj) {}
1523 	void exit(const(ObjectTypeDefinition) obj) {}
1524 
1525 	void accept(const(ObjectTypeDefinition) obj) {
1526 		enter(obj);
1527 		final switch(obj.ruleSelection) {
1528 			case ObjectTypeDefinitionEnum.ID:
1529 				obj.name.visit(this);
1530 				obj.ii.visit(this);
1531 				obj.dir.visit(this);
1532 				obj.fds.visit(this);
1533 				break;
1534 			case ObjectTypeDefinitionEnum.I:
1535 				obj.name.visit(this);
1536 				obj.ii.visit(this);
1537 				obj.fds.visit(this);
1538 				break;
1539 			case ObjectTypeDefinitionEnum.D:
1540 				obj.name.visit(this);
1541 				obj.dir.visit(this);
1542 				obj.fds.visit(this);
1543 				break;
1544 			case ObjectTypeDefinitionEnum.F:
1545 				obj.name.visit(this);
1546 				obj.fds.visit(this);
1547 				break;
1548 		}
1549 		exit(obj);
1550 	}
1551 
1552 	void enter(FieldDefinitions obj) {}
1553 	void exit(FieldDefinitions obj) {}
1554 
1555 	void accept(FieldDefinitions obj) {
1556 		enter(obj);
1557 		final switch(obj.ruleSelection) {
1558 			case FieldDefinitionsEnum.F:
1559 				obj.fd.visit(this);
1560 				break;
1561 			case FieldDefinitionsEnum.FC:
1562 				obj.fd.visit(this);
1563 				obj.follow.visit(this);
1564 				break;
1565 			case FieldDefinitionsEnum.FNC:
1566 				obj.fd.visit(this);
1567 				obj.follow.visit(this);
1568 				break;
1569 		}
1570 		exit(obj);
1571 	}
1572 
1573 	void enter(const(FieldDefinitions) obj) {}
1574 	void exit(const(FieldDefinitions) obj) {}
1575 
1576 	void accept(const(FieldDefinitions) obj) {
1577 		enter(obj);
1578 		final switch(obj.ruleSelection) {
1579 			case FieldDefinitionsEnum.F:
1580 				obj.fd.visit(this);
1581 				break;
1582 			case FieldDefinitionsEnum.FC:
1583 				obj.fd.visit(this);
1584 				obj.follow.visit(this);
1585 				break;
1586 			case FieldDefinitionsEnum.FNC:
1587 				obj.fd.visit(this);
1588 				obj.follow.visit(this);
1589 				break;
1590 		}
1591 		exit(obj);
1592 	}
1593 
1594 	void enter(FieldDefinition obj) {}
1595 	void exit(FieldDefinition obj) {}
1596 
1597 	void accept(FieldDefinition obj) {
1598 		enter(obj);
1599 		final switch(obj.ruleSelection) {
1600 			case FieldDefinitionEnum.AD:
1601 				obj.name.visit(this);
1602 				obj.arg.visit(this);
1603 				obj.typ.visit(this);
1604 				obj.dir.visit(this);
1605 				break;
1606 			case FieldDefinitionEnum.A:
1607 				obj.name.visit(this);
1608 				obj.arg.visit(this);
1609 				obj.typ.visit(this);
1610 				break;
1611 			case FieldDefinitionEnum.D:
1612 				obj.name.visit(this);
1613 				obj.typ.visit(this);
1614 				obj.dir.visit(this);
1615 				break;
1616 			case FieldDefinitionEnum.T:
1617 				obj.name.visit(this);
1618 				obj.typ.visit(this);
1619 				break;
1620 		}
1621 		exit(obj);
1622 	}
1623 
1624 	void enter(const(FieldDefinition) obj) {}
1625 	void exit(const(FieldDefinition) obj) {}
1626 
1627 	void accept(const(FieldDefinition) obj) {
1628 		enter(obj);
1629 		final switch(obj.ruleSelection) {
1630 			case FieldDefinitionEnum.AD:
1631 				obj.name.visit(this);
1632 				obj.arg.visit(this);
1633 				obj.typ.visit(this);
1634 				obj.dir.visit(this);
1635 				break;
1636 			case FieldDefinitionEnum.A:
1637 				obj.name.visit(this);
1638 				obj.arg.visit(this);
1639 				obj.typ.visit(this);
1640 				break;
1641 			case FieldDefinitionEnum.D:
1642 				obj.name.visit(this);
1643 				obj.typ.visit(this);
1644 				obj.dir.visit(this);
1645 				break;
1646 			case FieldDefinitionEnum.T:
1647 				obj.name.visit(this);
1648 				obj.typ.visit(this);
1649 				break;
1650 		}
1651 		exit(obj);
1652 	}
1653 
1654 	void enter(ImplementsInterfaces obj) {}
1655 	void exit(ImplementsInterfaces obj) {}
1656 
1657 	void accept(ImplementsInterfaces obj) {
1658 		enter(obj);
1659 		final switch(obj.ruleSelection) {
1660 			case ImplementsInterfacesEnum.N:
1661 				obj.nts.visit(this);
1662 				break;
1663 		}
1664 		exit(obj);
1665 	}
1666 
1667 	void enter(const(ImplementsInterfaces) obj) {}
1668 	void exit(const(ImplementsInterfaces) obj) {}
1669 
1670 	void accept(const(ImplementsInterfaces) obj) {
1671 		enter(obj);
1672 		final switch(obj.ruleSelection) {
1673 			case ImplementsInterfacesEnum.N:
1674 				obj.nts.visit(this);
1675 				break;
1676 		}
1677 		exit(obj);
1678 	}
1679 
1680 	void enter(NamedTypes obj) {}
1681 	void exit(NamedTypes obj) {}
1682 
1683 	void accept(NamedTypes obj) {
1684 		enter(obj);
1685 		final switch(obj.ruleSelection) {
1686 			case NamedTypesEnum.N:
1687 				obj.name.visit(this);
1688 				break;
1689 			case NamedTypesEnum.NCS:
1690 				obj.name.visit(this);
1691 				obj.follow.visit(this);
1692 				break;
1693 			case NamedTypesEnum.NS:
1694 				obj.name.visit(this);
1695 				obj.follow.visit(this);
1696 				break;
1697 		}
1698 		exit(obj);
1699 	}
1700 
1701 	void enter(const(NamedTypes) obj) {}
1702 	void exit(const(NamedTypes) obj) {}
1703 
1704 	void accept(const(NamedTypes) obj) {
1705 		enter(obj);
1706 		final switch(obj.ruleSelection) {
1707 			case NamedTypesEnum.N:
1708 				obj.name.visit(this);
1709 				break;
1710 			case NamedTypesEnum.NCS:
1711 				obj.name.visit(this);
1712 				obj.follow.visit(this);
1713 				break;
1714 			case NamedTypesEnum.NS:
1715 				obj.name.visit(this);
1716 				obj.follow.visit(this);
1717 				break;
1718 		}
1719 		exit(obj);
1720 	}
1721 
1722 	void enter(ArgumentsDefinition obj) {}
1723 	void exit(ArgumentsDefinition obj) {}
1724 
1725 	void accept(ArgumentsDefinition obj) {
1726 		enter(obj);
1727 		final switch(obj.ruleSelection) {
1728 			case ArgumentsDefinitionEnum.A:
1729 				break;
1730 		}
1731 		exit(obj);
1732 	}
1733 
1734 	void enter(const(ArgumentsDefinition) obj) {}
1735 	void exit(const(ArgumentsDefinition) obj) {}
1736 
1737 	void accept(const(ArgumentsDefinition) obj) {
1738 		enter(obj);
1739 		final switch(obj.ruleSelection) {
1740 			case ArgumentsDefinitionEnum.A:
1741 				break;
1742 		}
1743 		exit(obj);
1744 	}
1745 
1746 	void enter(InputValueDefinitions obj) {}
1747 	void exit(InputValueDefinitions obj) {}
1748 
1749 	void accept(InputValueDefinitions obj) {
1750 		enter(obj);
1751 		final switch(obj.ruleSelection) {
1752 			case InputValueDefinitionsEnum.I:
1753 				obj.iv.visit(this);
1754 				break;
1755 			case InputValueDefinitionsEnum.ICF:
1756 				obj.iv.visit(this);
1757 				obj.follow.visit(this);
1758 				break;
1759 			case InputValueDefinitionsEnum.IF:
1760 				obj.iv.visit(this);
1761 				obj.follow.visit(this);
1762 				break;
1763 		}
1764 		exit(obj);
1765 	}
1766 
1767 	void enter(const(InputValueDefinitions) obj) {}
1768 	void exit(const(InputValueDefinitions) obj) {}
1769 
1770 	void accept(const(InputValueDefinitions) obj) {
1771 		enter(obj);
1772 		final switch(obj.ruleSelection) {
1773 			case InputValueDefinitionsEnum.I:
1774 				obj.iv.visit(this);
1775 				break;
1776 			case InputValueDefinitionsEnum.ICF:
1777 				obj.iv.visit(this);
1778 				obj.follow.visit(this);
1779 				break;
1780 			case InputValueDefinitionsEnum.IF:
1781 				obj.iv.visit(this);
1782 				obj.follow.visit(this);
1783 				break;
1784 		}
1785 		exit(obj);
1786 	}
1787 
1788 	void enter(InputValueDefinition obj) {}
1789 	void exit(InputValueDefinition obj) {}
1790 
1791 	void accept(InputValueDefinition obj) {
1792 		enter(obj);
1793 		final switch(obj.ruleSelection) {
1794 			case InputValueDefinitionEnum.TVD:
1795 				obj.name.visit(this);
1796 				obj.type.visit(this);
1797 				obj.df.visit(this);
1798 				obj.dirs.visit(this);
1799 				break;
1800 			case InputValueDefinitionEnum.TD:
1801 				obj.name.visit(this);
1802 				obj.type.visit(this);
1803 				obj.dirs.visit(this);
1804 				break;
1805 			case InputValueDefinitionEnum.TV:
1806 				obj.name.visit(this);
1807 				obj.type.visit(this);
1808 				obj.df.visit(this);
1809 				break;
1810 			case InputValueDefinitionEnum.T:
1811 				obj.name.visit(this);
1812 				obj.type.visit(this);
1813 				break;
1814 		}
1815 		exit(obj);
1816 	}
1817 
1818 	void enter(const(InputValueDefinition) obj) {}
1819 	void exit(const(InputValueDefinition) obj) {}
1820 
1821 	void accept(const(InputValueDefinition) obj) {
1822 		enter(obj);
1823 		final switch(obj.ruleSelection) {
1824 			case InputValueDefinitionEnum.TVD:
1825 				obj.name.visit(this);
1826 				obj.type.visit(this);
1827 				obj.df.visit(this);
1828 				obj.dirs.visit(this);
1829 				break;
1830 			case InputValueDefinitionEnum.TD:
1831 				obj.name.visit(this);
1832 				obj.type.visit(this);
1833 				obj.dirs.visit(this);
1834 				break;
1835 			case InputValueDefinitionEnum.TV:
1836 				obj.name.visit(this);
1837 				obj.type.visit(this);
1838 				obj.df.visit(this);
1839 				break;
1840 			case InputValueDefinitionEnum.T:
1841 				obj.name.visit(this);
1842 				obj.type.visit(this);
1843 				break;
1844 		}
1845 		exit(obj);
1846 	}
1847 
1848 	void enter(InterfaceTypeDefinition obj) {}
1849 	void exit(InterfaceTypeDefinition obj) {}
1850 
1851 	void accept(InterfaceTypeDefinition obj) {
1852 		enter(obj);
1853 		final switch(obj.ruleSelection) {
1854 			case InterfaceTypeDefinitionEnum.NDF:
1855 				obj.name.visit(this);
1856 				obj.dirs.visit(this);
1857 				obj.fds.visit(this);
1858 				break;
1859 			case InterfaceTypeDefinitionEnum.NF:
1860 				obj.name.visit(this);
1861 				obj.fds.visit(this);
1862 				break;
1863 		}
1864 		exit(obj);
1865 	}
1866 
1867 	void enter(const(InterfaceTypeDefinition) obj) {}
1868 	void exit(const(InterfaceTypeDefinition) obj) {}
1869 
1870 	void accept(const(InterfaceTypeDefinition) obj) {
1871 		enter(obj);
1872 		final switch(obj.ruleSelection) {
1873 			case InterfaceTypeDefinitionEnum.NDF:
1874 				obj.name.visit(this);
1875 				obj.dirs.visit(this);
1876 				obj.fds.visit(this);
1877 				break;
1878 			case InterfaceTypeDefinitionEnum.NF:
1879 				obj.name.visit(this);
1880 				obj.fds.visit(this);
1881 				break;
1882 		}
1883 		exit(obj);
1884 	}
1885 
1886 	void enter(UnionTypeDefinition obj) {}
1887 	void exit(UnionTypeDefinition obj) {}
1888 
1889 	void accept(UnionTypeDefinition obj) {
1890 		enter(obj);
1891 		final switch(obj.ruleSelection) {
1892 			case UnionTypeDefinitionEnum.NDU:
1893 				obj.name.visit(this);
1894 				obj.dirs.visit(this);
1895 				obj.um.visit(this);
1896 				break;
1897 			case UnionTypeDefinitionEnum.NU:
1898 				obj.name.visit(this);
1899 				obj.um.visit(this);
1900 				break;
1901 		}
1902 		exit(obj);
1903 	}
1904 
1905 	void enter(const(UnionTypeDefinition) obj) {}
1906 	void exit(const(UnionTypeDefinition) obj) {}
1907 
1908 	void accept(const(UnionTypeDefinition) obj) {
1909 		enter(obj);
1910 		final switch(obj.ruleSelection) {
1911 			case UnionTypeDefinitionEnum.NDU:
1912 				obj.name.visit(this);
1913 				obj.dirs.visit(this);
1914 				obj.um.visit(this);
1915 				break;
1916 			case UnionTypeDefinitionEnum.NU:
1917 				obj.name.visit(this);
1918 				obj.um.visit(this);
1919 				break;
1920 		}
1921 		exit(obj);
1922 	}
1923 
1924 	void enter(UnionMembers obj) {}
1925 	void exit(UnionMembers obj) {}
1926 
1927 	void accept(UnionMembers obj) {
1928 		enter(obj);
1929 		final switch(obj.ruleSelection) {
1930 			case UnionMembersEnum.S:
1931 				obj.name.visit(this);
1932 				break;
1933 			case UnionMembersEnum.SPF:
1934 				obj.name.visit(this);
1935 				obj.follow.visit(this);
1936 				break;
1937 			case UnionMembersEnum.SF:
1938 				obj.name.visit(this);
1939 				obj.follow.visit(this);
1940 				break;
1941 		}
1942 		exit(obj);
1943 	}
1944 
1945 	void enter(const(UnionMembers) obj) {}
1946 	void exit(const(UnionMembers) obj) {}
1947 
1948 	void accept(const(UnionMembers) obj) {
1949 		enter(obj);
1950 		final switch(obj.ruleSelection) {
1951 			case UnionMembersEnum.S:
1952 				obj.name.visit(this);
1953 				break;
1954 			case UnionMembersEnum.SPF:
1955 				obj.name.visit(this);
1956 				obj.follow.visit(this);
1957 				break;
1958 			case UnionMembersEnum.SF:
1959 				obj.name.visit(this);
1960 				obj.follow.visit(this);
1961 				break;
1962 		}
1963 		exit(obj);
1964 	}
1965 
1966 	void enter(EnumTypeDefinition obj) {}
1967 	void exit(EnumTypeDefinition obj) {}
1968 
1969 	void accept(EnumTypeDefinition obj) {
1970 		enter(obj);
1971 		final switch(obj.ruleSelection) {
1972 			case EnumTypeDefinitionEnum.NDE:
1973 				obj.name.visit(this);
1974 				obj.dir.visit(this);
1975 				obj.evds.visit(this);
1976 				break;
1977 			case EnumTypeDefinitionEnum.NE:
1978 				obj.name.visit(this);
1979 				obj.evds.visit(this);
1980 				break;
1981 		}
1982 		exit(obj);
1983 	}
1984 
1985 	void enter(const(EnumTypeDefinition) obj) {}
1986 	void exit(const(EnumTypeDefinition) obj) {}
1987 
1988 	void accept(const(EnumTypeDefinition) obj) {
1989 		enter(obj);
1990 		final switch(obj.ruleSelection) {
1991 			case EnumTypeDefinitionEnum.NDE:
1992 				obj.name.visit(this);
1993 				obj.dir.visit(this);
1994 				obj.evds.visit(this);
1995 				break;
1996 			case EnumTypeDefinitionEnum.NE:
1997 				obj.name.visit(this);
1998 				obj.evds.visit(this);
1999 				break;
2000 		}
2001 		exit(obj);
2002 	}
2003 
2004 	void enter(EnumValueDefinitions obj) {}
2005 	void exit(EnumValueDefinitions obj) {}
2006 
2007 	void accept(EnumValueDefinitions obj) {
2008 		enter(obj);
2009 		final switch(obj.ruleSelection) {
2010 			case EnumValueDefinitionsEnum.D:
2011 				obj.evd.visit(this);
2012 				break;
2013 			case EnumValueDefinitionsEnum.DCE:
2014 				obj.evd.visit(this);
2015 				obj.follow.visit(this);
2016 				break;
2017 			case EnumValueDefinitionsEnum.DE:
2018 				obj.evd.visit(this);
2019 				obj.follow.visit(this);
2020 				break;
2021 		}
2022 		exit(obj);
2023 	}
2024 
2025 	void enter(const(EnumValueDefinitions) obj) {}
2026 	void exit(const(EnumValueDefinitions) obj) {}
2027 
2028 	void accept(const(EnumValueDefinitions) obj) {
2029 		enter(obj);
2030 		final switch(obj.ruleSelection) {
2031 			case EnumValueDefinitionsEnum.D:
2032 				obj.evd.visit(this);
2033 				break;
2034 			case EnumValueDefinitionsEnum.DCE:
2035 				obj.evd.visit(this);
2036 				obj.follow.visit(this);
2037 				break;
2038 			case EnumValueDefinitionsEnum.DE:
2039 				obj.evd.visit(this);
2040 				obj.follow.visit(this);
2041 				break;
2042 		}
2043 		exit(obj);
2044 	}
2045 
2046 	void enter(EnumValueDefinition obj) {}
2047 	void exit(EnumValueDefinition obj) {}
2048 
2049 	void accept(EnumValueDefinition obj) {
2050 		enter(obj);
2051 		final switch(obj.ruleSelection) {
2052 			case EnumValueDefinitionEnum.ED:
2053 				obj.name.visit(this);
2054 				obj.dirs.visit(this);
2055 				break;
2056 			case EnumValueDefinitionEnum.E:
2057 				obj.name.visit(this);
2058 				break;
2059 		}
2060 		exit(obj);
2061 	}
2062 
2063 	void enter(const(EnumValueDefinition) obj) {}
2064 	void exit(const(EnumValueDefinition) obj) {}
2065 
2066 	void accept(const(EnumValueDefinition) obj) {
2067 		enter(obj);
2068 		final switch(obj.ruleSelection) {
2069 			case EnumValueDefinitionEnum.ED:
2070 				obj.name.visit(this);
2071 				obj.dirs.visit(this);
2072 				break;
2073 			case EnumValueDefinitionEnum.E:
2074 				obj.name.visit(this);
2075 				break;
2076 		}
2077 		exit(obj);
2078 	}
2079 
2080 	void enter(InputTypeDefinition obj) {}
2081 	void exit(InputTypeDefinition obj) {}
2082 
2083 	void accept(InputTypeDefinition obj) {
2084 		enter(obj);
2085 		final switch(obj.ruleSelection) {
2086 			case InputTypeDefinitionEnum.NDE:
2087 				obj.name.visit(this);
2088 				obj.dir.visit(this);
2089 				obj.ivds.visit(this);
2090 				break;
2091 			case InputTypeDefinitionEnum.NE:
2092 				obj.name.visit(this);
2093 				obj.ivds.visit(this);
2094 				break;
2095 		}
2096 		exit(obj);
2097 	}
2098 
2099 	void enter(const(InputTypeDefinition) obj) {}
2100 	void exit(const(InputTypeDefinition) obj) {}
2101 
2102 	void accept(const(InputTypeDefinition) obj) {
2103 		enter(obj);
2104 		final switch(obj.ruleSelection) {
2105 			case InputTypeDefinitionEnum.NDE:
2106 				obj.name.visit(this);
2107 				obj.dir.visit(this);
2108 				obj.ivds.visit(this);
2109 				break;
2110 			case InputTypeDefinitionEnum.NE:
2111 				obj.name.visit(this);
2112 				obj.ivds.visit(this);
2113 				break;
2114 		}
2115 		exit(obj);
2116 	}
2117 
2118 	void enter(TypeExtensionDefinition obj) {}
2119 	void exit(TypeExtensionDefinition obj) {}
2120 
2121 	void accept(TypeExtensionDefinition obj) {
2122 		enter(obj);
2123 		final switch(obj.ruleSelection) {
2124 			case TypeExtensionDefinitionEnum.O:
2125 				obj.otd.visit(this);
2126 				break;
2127 		}
2128 		exit(obj);
2129 	}
2130 
2131 	void enter(const(TypeExtensionDefinition) obj) {}
2132 	void exit(const(TypeExtensionDefinition) obj) {}
2133 
2134 	void accept(const(TypeExtensionDefinition) obj) {
2135 		enter(obj);
2136 		final switch(obj.ruleSelection) {
2137 			case TypeExtensionDefinitionEnum.O:
2138 				obj.otd.visit(this);
2139 				break;
2140 		}
2141 		exit(obj);
2142 	}
2143 
2144 	void enter(DirectiveDefinition obj) {}
2145 	void exit(DirectiveDefinition obj) {}
2146 
2147 	void accept(DirectiveDefinition obj) {
2148 		enter(obj);
2149 		final switch(obj.ruleSelection) {
2150 			case DirectiveDefinitionEnum.AD:
2151 				obj.name.visit(this);
2152 				obj.ad.visit(this);
2153 				obj.dl.visit(this);
2154 				break;
2155 			case DirectiveDefinitionEnum.D:
2156 				obj.name.visit(this);
2157 				obj.dl.visit(this);
2158 				break;
2159 		}
2160 		exit(obj);
2161 	}
2162 
2163 	void enter(const(DirectiveDefinition) obj) {}
2164 	void exit(const(DirectiveDefinition) obj) {}
2165 
2166 	void accept(const(DirectiveDefinition) obj) {
2167 		enter(obj);
2168 		final switch(obj.ruleSelection) {
2169 			case DirectiveDefinitionEnum.AD:
2170 				obj.name.visit(this);
2171 				obj.ad.visit(this);
2172 				obj.dl.visit(this);
2173 				break;
2174 			case DirectiveDefinitionEnum.D:
2175 				obj.name.visit(this);
2176 				obj.dl.visit(this);
2177 				break;
2178 		}
2179 		exit(obj);
2180 	}
2181 
2182 	void enter(DirectiveLocations obj) {}
2183 	void exit(DirectiveLocations obj) {}
2184 
2185 	void accept(DirectiveLocations obj) {
2186 		enter(obj);
2187 		final switch(obj.ruleSelection) {
2188 			case DirectiveLocationsEnum.N:
2189 				obj.name.visit(this);
2190 				break;
2191 			case DirectiveLocationsEnum.NPF:
2192 				obj.name.visit(this);
2193 				obj.follow.visit(this);
2194 				break;
2195 			case DirectiveLocationsEnum.NF:
2196 				obj.name.visit(this);
2197 				obj.follow.visit(this);
2198 				break;
2199 		}
2200 		exit(obj);
2201 	}
2202 
2203 	void enter(const(DirectiveLocations) obj) {}
2204 	void exit(const(DirectiveLocations) obj) {}
2205 
2206 	void accept(const(DirectiveLocations) obj) {
2207 		enter(obj);
2208 		final switch(obj.ruleSelection) {
2209 			case DirectiveLocationsEnum.N:
2210 				obj.name.visit(this);
2211 				break;
2212 			case DirectiveLocationsEnum.NPF:
2213 				obj.name.visit(this);
2214 				obj.follow.visit(this);
2215 				break;
2216 			case DirectiveLocationsEnum.NF:
2217 				obj.name.visit(this);
2218 				obj.follow.visit(this);
2219 				break;
2220 		}
2221 		exit(obj);
2222 	}
2223 
2224 	void enter(InputObjectTypeDefinition obj) {}
2225 	void exit(InputObjectTypeDefinition obj) {}
2226 
2227 	void accept(InputObjectTypeDefinition obj) {
2228 		enter(obj);
2229 		final switch(obj.ruleSelection) {
2230 			case InputObjectTypeDefinitionEnum.NDI:
2231 				obj.name.visit(this);
2232 				obj.dirs.visit(this);
2233 				break;
2234 			case InputObjectTypeDefinitionEnum.NI:
2235 				obj.name.visit(this);
2236 				break;
2237 		}
2238 		exit(obj);
2239 	}
2240 
2241 	void enter(const(InputObjectTypeDefinition) obj) {}
2242 	void exit(const(InputObjectTypeDefinition) obj) {}
2243 
2244 	void accept(const(InputObjectTypeDefinition) obj) {
2245 		enter(obj);
2246 		final switch(obj.ruleSelection) {
2247 			case InputObjectTypeDefinitionEnum.NDI:
2248 				obj.name.visit(this);
2249 				obj.dirs.visit(this);
2250 				break;
2251 			case InputObjectTypeDefinitionEnum.NI:
2252 				obj.name.visit(this);
2253 				break;
2254 		}
2255 		exit(obj);
2256 	}
2257 }