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

Page generated by adrdox