Unofficial Dub Package Documentation 
1 module graphql.visitor;
2 
3 import graphql.ast;
4 import graphql.tokenmodule;
5 
6 @safe:
7 
8 class Visitor : ConstVisitor {
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 		}
533 		exit(obj);
534 	}
535 
536 	void enter(Type obj) {}
537 	void exit(Type obj) {}
538 
539 	void accept(Type obj) {
540 		enter(obj);
541 		final switch(obj.ruleSelection) {
542 			case TypeEnum.TN:
543 				obj.tname.visit(this);
544 				break;
545 			case TypeEnum.LN:
546 				obj.list.visit(this);
547 				break;
548 			case TypeEnum.T:
549 				obj.tname.visit(this);
550 				break;
551 			case TypeEnum.L:
552 				obj.list.visit(this);
553 				break;
554 		}
555 		exit(obj);
556 	}
557 
558 	void enter(ListType obj) {}
559 	void exit(ListType obj) {}
560 
561 	void accept(ListType obj) {
562 		enter(obj);
563 		final switch(obj.ruleSelection) {
564 			case ListTypeEnum.T:
565 				obj.type.visit(this);
566 				break;
567 		}
568 		exit(obj);
569 	}
570 
571 	void enter(Values obj) {}
572 	void exit(Values obj) {}
573 
574 	void accept(Values obj) {
575 		enter(obj);
576 		final switch(obj.ruleSelection) {
577 			case ValuesEnum.Val:
578 				obj.val.visit(this);
579 				break;
580 			case ValuesEnum.Vals:
581 				obj.val.visit(this);
582 				obj.follow.visit(this);
583 				break;
584 		}
585 		exit(obj);
586 	}
587 
588 	void enter(Array obj) {}
589 	void exit(Array obj) {}
590 
591 	void accept(Array obj) {
592 		enter(obj);
593 		final switch(obj.ruleSelection) {
594 			case ArrayEnum.Empty:
595 				break;
596 			case ArrayEnum.Value:
597 				obj.vals.visit(this);
598 				break;
599 		}
600 		exit(obj);
601 	}
602 
603 	void enter(ObjectValues obj) {}
604 	void exit(ObjectValues obj) {}
605 
606 	void accept(ObjectValues obj) {
607 		enter(obj);
608 		final switch(obj.ruleSelection) {
609 			case ObjectValuesEnum.V:
610 				obj.name.visit(this);
611 				obj.val.visit(this);
612 				break;
613 			case ObjectValuesEnum.Vsc:
614 				obj.name.visit(this);
615 				obj.val.visit(this);
616 				obj.follow.visit(this);
617 				break;
618 			case ObjectValuesEnum.Vs:
619 				obj.name.visit(this);
620 				obj.val.visit(this);
621 				obj.follow.visit(this);
622 				break;
623 		}
624 		exit(obj);
625 	}
626 
627 	void enter(ObjectType obj) {}
628 	void exit(ObjectType obj) {}
629 
630 	void accept(ObjectType obj) {
631 		enter(obj);
632 		final switch(obj.ruleSelection) {
633 			case ObjectTypeEnum.Var:
634 				obj.vals.visit(this);
635 				break;
636 		}
637 		exit(obj);
638 	}
639 
640 	void enter(TypeSystemDefinition obj) {}
641 	void exit(TypeSystemDefinition obj) {}
642 
643 	void accept(TypeSystemDefinition obj) {
644 		enter(obj);
645 		final switch(obj.ruleSelection) {
646 			case TypeSystemDefinitionEnum.S:
647 				obj.sch.visit(this);
648 				break;
649 			case TypeSystemDefinitionEnum.T:
650 				obj.td.visit(this);
651 				break;
652 			case TypeSystemDefinitionEnum.TE:
653 				obj.ted.visit(this);
654 				break;
655 			case TypeSystemDefinitionEnum.D:
656 				obj.dd.visit(this);
657 				break;
658 		}
659 		exit(obj);
660 	}
661 
662 	void enter(TypeDefinition obj) {}
663 	void exit(TypeDefinition obj) {}
664 
665 	void accept(TypeDefinition obj) {
666 		enter(obj);
667 		final switch(obj.ruleSelection) {
668 			case TypeDefinitionEnum.S:
669 				obj.std.visit(this);
670 				break;
671 			case TypeDefinitionEnum.O:
672 				obj.otd.visit(this);
673 				break;
674 			case TypeDefinitionEnum.I:
675 				obj.itd.visit(this);
676 				break;
677 			case TypeDefinitionEnum.U:
678 				obj.utd.visit(this);
679 				break;
680 			case TypeDefinitionEnum.E:
681 				obj.etd.visit(this);
682 				break;
683 			case TypeDefinitionEnum.IO:
684 				obj.iod.visit(this);
685 				break;
686 		}
687 		exit(obj);
688 	}
689 
690 	void enter(SchemaDefinition obj) {}
691 	void exit(SchemaDefinition obj) {}
692 
693 	void accept(SchemaDefinition obj) {
694 		enter(obj);
695 		final switch(obj.ruleSelection) {
696 			case SchemaDefinitionEnum.DO:
697 				obj.dir.visit(this);
698 				obj.otds.visit(this);
699 				break;
700 			case SchemaDefinitionEnum.O:
701 				obj.otds.visit(this);
702 				break;
703 		}
704 		exit(obj);
705 	}
706 
707 	void enter(OperationTypeDefinitions obj) {}
708 	void exit(OperationTypeDefinitions obj) {}
709 
710 	void accept(OperationTypeDefinitions obj) {
711 		enter(obj);
712 		final switch(obj.ruleSelection) {
713 			case OperationTypeDefinitionsEnum.O:
714 				obj.otd.visit(this);
715 				break;
716 			case OperationTypeDefinitionsEnum.OCS:
717 				obj.otd.visit(this);
718 				obj.follow.visit(this);
719 				break;
720 			case OperationTypeDefinitionsEnum.OS:
721 				obj.otd.visit(this);
722 				obj.follow.visit(this);
723 				break;
724 		}
725 		exit(obj);
726 	}
727 
728 	void enter(OperationTypeDefinition obj) {}
729 	void exit(OperationTypeDefinition obj) {}
730 
731 	void accept(OperationTypeDefinition obj) {
732 		enter(obj);
733 		final switch(obj.ruleSelection) {
734 			case OperationTypeDefinitionEnum.O:
735 				obj.ot.visit(this);
736 				obj.nt.visit(this);
737 				break;
738 		}
739 		exit(obj);
740 	}
741 
742 	void enter(ScalarTypeDefinition obj) {}
743 	void exit(ScalarTypeDefinition obj) {}
744 
745 	void accept(ScalarTypeDefinition obj) {
746 		enter(obj);
747 		final switch(obj.ruleSelection) {
748 			case ScalarTypeDefinitionEnum.D:
749 				obj.name.visit(this);
750 				obj.dir.visit(this);
751 				break;
752 			case ScalarTypeDefinitionEnum.S:
753 				obj.name.visit(this);
754 				break;
755 		}
756 		exit(obj);
757 	}
758 
759 	void enter(ObjectTypeDefinition obj) {}
760 	void exit(ObjectTypeDefinition obj) {}
761 
762 	void accept(ObjectTypeDefinition obj) {
763 		enter(obj);
764 		final switch(obj.ruleSelection) {
765 			case ObjectTypeDefinitionEnum.ID:
766 				obj.name.visit(this);
767 				obj.ii.visit(this);
768 				obj.dir.visit(this);
769 				obj.fds.visit(this);
770 				break;
771 			case ObjectTypeDefinitionEnum.I:
772 				obj.name.visit(this);
773 				obj.ii.visit(this);
774 				obj.fds.visit(this);
775 				break;
776 			case ObjectTypeDefinitionEnum.D:
777 				obj.name.visit(this);
778 				obj.dir.visit(this);
779 				obj.fds.visit(this);
780 				break;
781 			case ObjectTypeDefinitionEnum.F:
782 				obj.name.visit(this);
783 				obj.fds.visit(this);
784 				break;
785 		}
786 		exit(obj);
787 	}
788 
789 	void enter(FieldDefinitions obj) {}
790 	void exit(FieldDefinitions obj) {}
791 
792 	void accept(FieldDefinitions obj) {
793 		enter(obj);
794 		final switch(obj.ruleSelection) {
795 			case FieldDefinitionsEnum.F:
796 				obj.fd.visit(this);
797 				break;
798 			case FieldDefinitionsEnum.FC:
799 				obj.fd.visit(this);
800 				obj.follow.visit(this);
801 				break;
802 			case FieldDefinitionsEnum.FNC:
803 				obj.fd.visit(this);
804 				obj.follow.visit(this);
805 				break;
806 		}
807 		exit(obj);
808 	}
809 
810 	void enter(FieldDefinition obj) {}
811 	void exit(FieldDefinition obj) {}
812 
813 	void accept(FieldDefinition obj) {
814 		enter(obj);
815 		final switch(obj.ruleSelection) {
816 			case FieldDefinitionEnum.AD:
817 				obj.name.visit(this);
818 				obj.arg.visit(this);
819 				obj.typ.visit(this);
820 				obj.dir.visit(this);
821 				break;
822 			case FieldDefinitionEnum.A:
823 				obj.name.visit(this);
824 				obj.arg.visit(this);
825 				obj.typ.visit(this);
826 				break;
827 			case FieldDefinitionEnum.D:
828 				obj.name.visit(this);
829 				obj.typ.visit(this);
830 				obj.dir.visit(this);
831 				break;
832 			case FieldDefinitionEnum.T:
833 				obj.name.visit(this);
834 				obj.typ.visit(this);
835 				break;
836 		}
837 		exit(obj);
838 	}
839 
840 	void enter(ImplementsInterfaces obj) {}
841 	void exit(ImplementsInterfaces obj) {}
842 
843 	void accept(ImplementsInterfaces obj) {
844 		enter(obj);
845 		final switch(obj.ruleSelection) {
846 			case ImplementsInterfacesEnum.N:
847 				obj.nts.visit(this);
848 				break;
849 		}
850 		exit(obj);
851 	}
852 
853 	void enter(NamedTypes obj) {}
854 	void exit(NamedTypes obj) {}
855 
856 	void accept(NamedTypes obj) {
857 		enter(obj);
858 		final switch(obj.ruleSelection) {
859 			case NamedTypesEnum.N:
860 				obj.name.visit(this);
861 				break;
862 			case NamedTypesEnum.NCS:
863 				obj.name.visit(this);
864 				obj.follow.visit(this);
865 				break;
866 			case NamedTypesEnum.NS:
867 				obj.name.visit(this);
868 				obj.follow.visit(this);
869 				break;
870 		}
871 		exit(obj);
872 	}
873 
874 	void enter(ArgumentsDefinition obj) {}
875 	void exit(ArgumentsDefinition obj) {}
876 
877 	void accept(ArgumentsDefinition obj) {
878 		enter(obj);
879 		final switch(obj.ruleSelection) {
880 			case ArgumentsDefinitionEnum.A:
881 				break;
882 		}
883 		exit(obj);
884 	}
885 
886 	void enter(InputValueDefinitions obj) {}
887 	void exit(InputValueDefinitions obj) {}
888 
889 	void accept(InputValueDefinitions obj) {
890 		enter(obj);
891 		final switch(obj.ruleSelection) {
892 			case InputValueDefinitionsEnum.I:
893 				obj.iv.visit(this);
894 				break;
895 			case InputValueDefinitionsEnum.ICF:
896 				obj.iv.visit(this);
897 				obj.follow.visit(this);
898 				break;
899 			case InputValueDefinitionsEnum.IF:
900 				obj.iv.visit(this);
901 				obj.follow.visit(this);
902 				break;
903 		}
904 		exit(obj);
905 	}
906 
907 	void enter(InputValueDefinition obj) {}
908 	void exit(InputValueDefinition obj) {}
909 
910 	void accept(InputValueDefinition obj) {
911 		enter(obj);
912 		final switch(obj.ruleSelection) {
913 			case InputValueDefinitionEnum.TVD:
914 				obj.name.visit(this);
915 				obj.type.visit(this);
916 				obj.df.visit(this);
917 				obj.dirs.visit(this);
918 				break;
919 			case InputValueDefinitionEnum.TD:
920 				obj.name.visit(this);
921 				obj.type.visit(this);
922 				obj.dirs.visit(this);
923 				break;
924 			case InputValueDefinitionEnum.TV:
925 				obj.name.visit(this);
926 				obj.type.visit(this);
927 				obj.df.visit(this);
928 				break;
929 			case InputValueDefinitionEnum.T:
930 				obj.name.visit(this);
931 				obj.type.visit(this);
932 				break;
933 		}
934 		exit(obj);
935 	}
936 
937 	void enter(InterfaceTypeDefinition obj) {}
938 	void exit(InterfaceTypeDefinition obj) {}
939 
940 	void accept(InterfaceTypeDefinition obj) {
941 		enter(obj);
942 		final switch(obj.ruleSelection) {
943 			case InterfaceTypeDefinitionEnum.NDF:
944 				obj.name.visit(this);
945 				obj.dirs.visit(this);
946 				obj.fds.visit(this);
947 				break;
948 			case InterfaceTypeDefinitionEnum.NF:
949 				obj.name.visit(this);
950 				obj.fds.visit(this);
951 				break;
952 		}
953 		exit(obj);
954 	}
955 
956 	void enter(UnionTypeDefinition obj) {}
957 	void exit(UnionTypeDefinition obj) {}
958 
959 	void accept(UnionTypeDefinition obj) {
960 		enter(obj);
961 		final switch(obj.ruleSelection) {
962 			case UnionTypeDefinitionEnum.NDU:
963 				obj.name.visit(this);
964 				obj.dirs.visit(this);
965 				obj.um.visit(this);
966 				break;
967 			case UnionTypeDefinitionEnum.NU:
968 				obj.name.visit(this);
969 				obj.um.visit(this);
970 				break;
971 		}
972 		exit(obj);
973 	}
974 
975 	void enter(UnionMembers obj) {}
976 	void exit(UnionMembers obj) {}
977 
978 	void accept(UnionMembers obj) {
979 		enter(obj);
980 		final switch(obj.ruleSelection) {
981 			case UnionMembersEnum.S:
982 				obj.name.visit(this);
983 				break;
984 			case UnionMembersEnum.SPF:
985 				obj.name.visit(this);
986 				obj.follow.visit(this);
987 				break;
988 			case UnionMembersEnum.SF:
989 				obj.name.visit(this);
990 				obj.follow.visit(this);
991 				break;
992 		}
993 		exit(obj);
994 	}
995 
996 	void enter(EnumTypeDefinition obj) {}
997 	void exit(EnumTypeDefinition obj) {}
998 
999 	void accept(EnumTypeDefinition obj) {
1000 		enter(obj);
1001 		final switch(obj.ruleSelection) {
1002 			case EnumTypeDefinitionEnum.NDE:
1003 				obj.name.visit(this);
1004 				obj.dir.visit(this);
1005 				obj.evds.visit(this);
1006 				break;
1007 			case EnumTypeDefinitionEnum.NE:
1008 				obj.name.visit(this);
1009 				obj.evds.visit(this);
1010 				break;
1011 		}
1012 		exit(obj);
1013 	}
1014 
1015 	void enter(EnumValueDefinitions obj) {}
1016 	void exit(EnumValueDefinitions obj) {}
1017 
1018 	void accept(EnumValueDefinitions obj) {
1019 		enter(obj);
1020 		final switch(obj.ruleSelection) {
1021 			case EnumValueDefinitionsEnum.D:
1022 				obj.evd.visit(this);
1023 				break;
1024 			case EnumValueDefinitionsEnum.DCE:
1025 				obj.evd.visit(this);
1026 				obj.follow.visit(this);
1027 				break;
1028 			case EnumValueDefinitionsEnum.DE:
1029 				obj.evd.visit(this);
1030 				obj.follow.visit(this);
1031 				break;
1032 		}
1033 		exit(obj);
1034 	}
1035 
1036 	void enter(EnumValueDefinition obj) {}
1037 	void exit(EnumValueDefinition obj) {}
1038 
1039 	void accept(EnumValueDefinition obj) {
1040 		enter(obj);
1041 		final switch(obj.ruleSelection) {
1042 			case EnumValueDefinitionEnum.ED:
1043 				obj.name.visit(this);
1044 				obj.dirs.visit(this);
1045 				break;
1046 			case EnumValueDefinitionEnum.E:
1047 				obj.name.visit(this);
1048 				break;
1049 		}
1050 		exit(obj);
1051 	}
1052 
1053 	void enter(InputTypeDefinition obj) {}
1054 	void exit(InputTypeDefinition obj) {}
1055 
1056 	void accept(InputTypeDefinition obj) {
1057 		enter(obj);
1058 		final switch(obj.ruleSelection) {
1059 			case InputTypeDefinitionEnum.NDE:
1060 				obj.name.visit(this);
1061 				obj.dir.visit(this);
1062 				obj.ivds.visit(this);
1063 				break;
1064 			case InputTypeDefinitionEnum.NE:
1065 				obj.name.visit(this);
1066 				obj.ivds.visit(this);
1067 				break;
1068 		}
1069 		exit(obj);
1070 	}
1071 
1072 	void enter(TypeExtensionDefinition obj) {}
1073 	void exit(TypeExtensionDefinition obj) {}
1074 
1075 	void accept(TypeExtensionDefinition obj) {
1076 		enter(obj);
1077 		final switch(obj.ruleSelection) {
1078 			case TypeExtensionDefinitionEnum.O:
1079 				obj.otd.visit(this);
1080 				break;
1081 		}
1082 		exit(obj);
1083 	}
1084 
1085 	void enter(DirectiveDefinition obj) {}
1086 	void exit(DirectiveDefinition obj) {}
1087 
1088 	void accept(DirectiveDefinition obj) {
1089 		enter(obj);
1090 		final switch(obj.ruleSelection) {
1091 			case DirectiveDefinitionEnum.AD:
1092 				obj.name.visit(this);
1093 				obj.ad.visit(this);
1094 				obj.dl.visit(this);
1095 				break;
1096 			case DirectiveDefinitionEnum.D:
1097 				obj.name.visit(this);
1098 				obj.dl.visit(this);
1099 				break;
1100 		}
1101 		exit(obj);
1102 	}
1103 
1104 	void enter(DirectiveLocations obj) {}
1105 	void exit(DirectiveLocations obj) {}
1106 
1107 	void accept(DirectiveLocations obj) {
1108 		enter(obj);
1109 		final switch(obj.ruleSelection) {
1110 			case DirectiveLocationsEnum.N:
1111 				obj.name.visit(this);
1112 				break;
1113 			case DirectiveLocationsEnum.NPF:
1114 				obj.name.visit(this);
1115 				obj.follow.visit(this);
1116 				break;
1117 			case DirectiveLocationsEnum.NF:
1118 				obj.name.visit(this);
1119 				obj.follow.visit(this);
1120 				break;
1121 		}
1122 		exit(obj);
1123 	}
1124 
1125 	void enter(InputObjectTypeDefinition obj) {}
1126 	void exit(InputObjectTypeDefinition obj) {}
1127 
1128 	void accept(InputObjectTypeDefinition obj) {
1129 		enter(obj);
1130 		final switch(obj.ruleSelection) {
1131 			case InputObjectTypeDefinitionEnum.NDI:
1132 				obj.name.visit(this);
1133 				obj.dirs.visit(this);
1134 				break;
1135 			case InputObjectTypeDefinitionEnum.NI:
1136 				obj.name.visit(this);
1137 				break;
1138 		}
1139 		exit(obj);
1140 	}
1141 }
1142 
1143 class ConstVisitor {
1144 
1145 	void enter(const(Document) obj) {}
1146 	void exit(const(Document) obj) {}
1147 
1148 	void accept(const(Document) obj) {
1149 		enter(obj);
1150 		final switch(obj.ruleSelection) {
1151 			case DocumentEnum.Defi:
1152 				obj.defs.visit(this);
1153 				break;
1154 		}
1155 		exit(obj);
1156 	}
1157 
1158 	void enter(const(Definitions) obj) {}
1159 	void exit(const(Definitions) obj) {}
1160 
1161 	void accept(const(Definitions) obj) {
1162 		enter(obj);
1163 		final switch(obj.ruleSelection) {
1164 			case DefinitionsEnum.Def:
1165 				obj.def.visit(this);
1166 				break;
1167 			case DefinitionsEnum.Defs:
1168 				obj.def.visit(this);
1169 				obj.follow.visit(this);
1170 				break;
1171 		}
1172 		exit(obj);
1173 	}
1174 
1175 	void enter(const(Definition) obj) {}
1176 	void exit(const(Definition) obj) {}
1177 
1178 	void accept(const(Definition) obj) {
1179 		enter(obj);
1180 		final switch(obj.ruleSelection) {
1181 			case DefinitionEnum.O:
1182 				obj.op.visit(this);
1183 				break;
1184 			case DefinitionEnum.F:
1185 				obj.frag.visit(this);
1186 				break;
1187 			case DefinitionEnum.T:
1188 				obj.type.visit(this);
1189 				break;
1190 		}
1191 		exit(obj);
1192 	}
1193 
1194 	void enter(const(OperationDefinition) obj) {}
1195 	void exit(const(OperationDefinition) obj) {}
1196 
1197 	void accept(const(OperationDefinition) obj) {
1198 		enter(obj);
1199 		final switch(obj.ruleSelection) {
1200 			case OperationDefinitionEnum.SelSet:
1201 				obj.ss.visit(this);
1202 				break;
1203 			case OperationDefinitionEnum.OT_N_VD:
1204 				obj.ot.visit(this);
1205 				obj.name.visit(this);
1206 				obj.vd.visit(this);
1207 				obj.d.visit(this);
1208 				obj.ss.visit(this);
1209 				break;
1210 			case OperationDefinitionEnum.OT_N_V:
1211 				obj.ot.visit(this);
1212 				obj.name.visit(this);
1213 				obj.vd.visit(this);
1214 				obj.ss.visit(this);
1215 				break;
1216 			case OperationDefinitionEnum.OT_N_D:
1217 				obj.ot.visit(this);
1218 				obj.name.visit(this);
1219 				obj.d.visit(this);
1220 				obj.ss.visit(this);
1221 				break;
1222 			case OperationDefinitionEnum.OT_N:
1223 				obj.ot.visit(this);
1224 				obj.name.visit(this);
1225 				obj.ss.visit(this);
1226 				break;
1227 			case OperationDefinitionEnum.OT_VD:
1228 				obj.ot.visit(this);
1229 				obj.vd.visit(this);
1230 				obj.d.visit(this);
1231 				obj.ss.visit(this);
1232 				break;
1233 			case OperationDefinitionEnum.OT_V:
1234 				obj.ot.visit(this);
1235 				obj.vd.visit(this);
1236 				obj.ss.visit(this);
1237 				break;
1238 			case OperationDefinitionEnum.OT_D:
1239 				obj.ot.visit(this);
1240 				obj.d.visit(this);
1241 				obj.ss.visit(this);
1242 				break;
1243 			case OperationDefinitionEnum.OT:
1244 				obj.ot.visit(this);
1245 				obj.ss.visit(this);
1246 				break;
1247 		}
1248 		exit(obj);
1249 	}
1250 
1251 	void enter(const(SelectionSet) obj) {}
1252 	void exit(const(SelectionSet) obj) {}
1253 
1254 	void accept(const(SelectionSet) obj) {
1255 		enter(obj);
1256 		final switch(obj.ruleSelection) {
1257 			case SelectionSetEnum.SS:
1258 				obj.sel.visit(this);
1259 				break;
1260 		}
1261 		exit(obj);
1262 	}
1263 
1264 	void enter(const(OperationType) obj) {}
1265 	void exit(const(OperationType) obj) {}
1266 
1267 	void accept(const(OperationType) obj) {
1268 		enter(obj);
1269 		final switch(obj.ruleSelection) {
1270 			case OperationTypeEnum.Query:
1271 				obj.tok.visit(this);
1272 				break;
1273 			case OperationTypeEnum.Mutation:
1274 				obj.tok.visit(this);
1275 				break;
1276 			case OperationTypeEnum.Sub:
1277 				obj.tok.visit(this);
1278 				break;
1279 		}
1280 		exit(obj);
1281 	}
1282 
1283 	void enter(const(Selections) obj) {}
1284 	void exit(const(Selections) obj) {}
1285 
1286 	void accept(const(Selections) obj) {
1287 		enter(obj);
1288 		final switch(obj.ruleSelection) {
1289 			case SelectionsEnum.Sel:
1290 				obj.sel.visit(this);
1291 				break;
1292 			case SelectionsEnum.Sels:
1293 				obj.sel.visit(this);
1294 				obj.follow.visit(this);
1295 				break;
1296 			case SelectionsEnum.Selsc:
1297 				obj.sel.visit(this);
1298 				obj.follow.visit(this);
1299 				break;
1300 		}
1301 		exit(obj);
1302 	}
1303 
1304 	void enter(const(Selection) obj) {}
1305 	void exit(const(Selection) obj) {}
1306 
1307 	void accept(const(Selection) obj) {
1308 		enter(obj);
1309 		final switch(obj.ruleSelection) {
1310 			case SelectionEnum.Field:
1311 				obj.field.visit(this);
1312 				break;
1313 			case SelectionEnum.Spread:
1314 				obj.frag.visit(this);
1315 				break;
1316 			case SelectionEnum.IFrag:
1317 				obj.ifrag.visit(this);
1318 				break;
1319 		}
1320 		exit(obj);
1321 	}
1322 
1323 	void enter(const(FragmentSpread) obj) {}
1324 	void exit(const(FragmentSpread) obj) {}
1325 
1326 	void accept(const(FragmentSpread) obj) {
1327 		enter(obj);
1328 		final switch(obj.ruleSelection) {
1329 			case FragmentSpreadEnum.FD:
1330 				obj.name.visit(this);
1331 				obj.dirs.visit(this);
1332 				break;
1333 			case FragmentSpreadEnum.F:
1334 				obj.name.visit(this);
1335 				break;
1336 		}
1337 		exit(obj);
1338 	}
1339 
1340 	void enter(const(InlineFragment) obj) {}
1341 	void exit(const(InlineFragment) obj) {}
1342 
1343 	void accept(const(InlineFragment) obj) {
1344 		enter(obj);
1345 		final switch(obj.ruleSelection) {
1346 			case InlineFragmentEnum.TDS:
1347 				obj.tc.visit(this);
1348 				obj.dirs.visit(this);
1349 				obj.ss.visit(this);
1350 				break;
1351 			case InlineFragmentEnum.TS:
1352 				obj.tc.visit(this);
1353 				obj.ss.visit(this);
1354 				break;
1355 			case InlineFragmentEnum.DS:
1356 				obj.dirs.visit(this);
1357 				obj.ss.visit(this);
1358 				break;
1359 			case InlineFragmentEnum.S:
1360 				obj.ss.visit(this);
1361 				break;
1362 		}
1363 		exit(obj);
1364 	}
1365 
1366 	void enter(const(Field) obj) {}
1367 	void exit(const(Field) obj) {}
1368 
1369 	void accept(const(Field) obj) {
1370 		enter(obj);
1371 		final switch(obj.ruleSelection) {
1372 			case FieldEnum.FADS:
1373 				obj.name.visit(this);
1374 				obj.args.visit(this);
1375 				obj.dirs.visit(this);
1376 				obj.ss.visit(this);
1377 				break;
1378 			case FieldEnum.FAS:
1379 				obj.name.visit(this);
1380 				obj.args.visit(this);
1381 				obj.ss.visit(this);
1382 				break;
1383 			case FieldEnum.FAD:
1384 				obj.name.visit(this);
1385 				obj.args.visit(this);
1386 				obj.dirs.visit(this);
1387 				break;
1388 			case FieldEnum.FDS:
1389 				obj.name.visit(this);
1390 				obj.dirs.visit(this);
1391 				obj.ss.visit(this);
1392 				break;
1393 			case FieldEnum.FS:
1394 				obj.name.visit(this);
1395 				obj.ss.visit(this);
1396 				break;
1397 			case FieldEnum.FD:
1398 				obj.name.visit(this);
1399 				obj.dirs.visit(this);
1400 				break;
1401 			case FieldEnum.FA:
1402 				obj.name.visit(this);
1403 				obj.args.visit(this);
1404 				break;
1405 			case FieldEnum.F:
1406 				obj.name.visit(this);
1407 				break;
1408 		}
1409 		exit(obj);
1410 	}
1411 
1412 	void enter(const(FieldName) obj) {}
1413 	void exit(const(FieldName) obj) {}
1414 
1415 	void accept(const(FieldName) obj) {
1416 		enter(obj);
1417 		final switch(obj.ruleSelection) {
1418 			case FieldNameEnum.A:
1419 				obj.name.visit(this);
1420 				obj.aka.visit(this);
1421 				break;
1422 			case FieldNameEnum.N:
1423 				obj.name.visit(this);
1424 				break;
1425 		}
1426 		exit(obj);
1427 	}
1428 
1429 	void enter(const(Arguments) obj) {}
1430 	void exit(const(Arguments) obj) {}
1431 
1432 	void accept(const(Arguments) obj) {
1433 		enter(obj);
1434 		final switch(obj.ruleSelection) {
1435 			case ArgumentsEnum.List:
1436 				obj.arg.visit(this);
1437 				break;
1438 			case ArgumentsEnum.Empty:
1439 				break;
1440 		}
1441 		exit(obj);
1442 	}
1443 
1444 	void enter(const(ArgumentList) obj) {}
1445 	void exit(const(ArgumentList) obj) {}
1446 
1447 	void accept(const(ArgumentList) obj) {
1448 		enter(obj);
1449 		final switch(obj.ruleSelection) {
1450 			case ArgumentListEnum.A:
1451 				obj.arg.visit(this);
1452 				break;
1453 			case ArgumentListEnum.ACS:
1454 				obj.arg.visit(this);
1455 				obj.follow.visit(this);
1456 				break;
1457 			case ArgumentListEnum.AS:
1458 				obj.arg.visit(this);
1459 				obj.follow.visit(this);
1460 				break;
1461 		}
1462 		exit(obj);
1463 	}
1464 
1465 	void enter(const(Argument) obj) {}
1466 	void exit(const(Argument) obj) {}
1467 
1468 	void accept(const(Argument) obj) {
1469 		enter(obj);
1470 		final switch(obj.ruleSelection) {
1471 			case ArgumentEnum.Name:
1472 				obj.name.visit(this);
1473 				obj.vv.visit(this);
1474 				break;
1475 		}
1476 		exit(obj);
1477 	}
1478 
1479 	void enter(const(FragmentDefinition) obj) {}
1480 	void exit(const(FragmentDefinition) obj) {}
1481 
1482 	void accept(const(FragmentDefinition) obj) {
1483 		enter(obj);
1484 		final switch(obj.ruleSelection) {
1485 			case FragmentDefinitionEnum.FTDS:
1486 				obj.name.visit(this);
1487 				obj.tc.visit(this);
1488 				obj.dirs.visit(this);
1489 				obj.ss.visit(this);
1490 				break;
1491 			case FragmentDefinitionEnum.FTS:
1492 				obj.name.visit(this);
1493 				obj.tc.visit(this);
1494 				obj.ss.visit(this);
1495 				break;
1496 		}
1497 		exit(obj);
1498 	}
1499 
1500 	void enter(const(Directives) obj) {}
1501 	void exit(const(Directives) obj) {}
1502 
1503 	void accept(const(Directives) obj) {
1504 		enter(obj);
1505 		final switch(obj.ruleSelection) {
1506 			case DirectivesEnum.Dir:
1507 				obj.dir.visit(this);
1508 				break;
1509 			case DirectivesEnum.Dirs:
1510 				obj.dir.visit(this);
1511 				obj.follow.visit(this);
1512 				break;
1513 		}
1514 		exit(obj);
1515 	}
1516 
1517 	void enter(const(Directive) obj) {}
1518 	void exit(const(Directive) obj) {}
1519 
1520 	void accept(const(Directive) obj) {
1521 		enter(obj);
1522 		final switch(obj.ruleSelection) {
1523 			case DirectiveEnum.NArg:
1524 				obj.name.visit(this);
1525 				obj.arg.visit(this);
1526 				break;
1527 			case DirectiveEnum.N:
1528 				obj.name.visit(this);
1529 				break;
1530 		}
1531 		exit(obj);
1532 	}
1533 
1534 	void enter(const(VariableDefinitions) obj) {}
1535 	void exit(const(VariableDefinitions) obj) {}
1536 
1537 	void accept(const(VariableDefinitions) obj) {
1538 		enter(obj);
1539 		final switch(obj.ruleSelection) {
1540 			case VariableDefinitionsEnum.Empty:
1541 				break;
1542 			case VariableDefinitionsEnum.Vars:
1543 				obj.vars.visit(this);
1544 				break;
1545 		}
1546 		exit(obj);
1547 	}
1548 
1549 	void enter(const(VariableDefinitionList) obj) {}
1550 	void exit(const(VariableDefinitionList) obj) {}
1551 
1552 	void accept(const(VariableDefinitionList) obj) {
1553 		enter(obj);
1554 		final switch(obj.ruleSelection) {
1555 			case VariableDefinitionListEnum.V:
1556 				obj.var.visit(this);
1557 				break;
1558 			case VariableDefinitionListEnum.VCF:
1559 				obj.var.visit(this);
1560 				obj.follow.visit(this);
1561 				break;
1562 			case VariableDefinitionListEnum.VF:
1563 				obj.var.visit(this);
1564 				obj.follow.visit(this);
1565 				break;
1566 		}
1567 		exit(obj);
1568 	}
1569 
1570 	void enter(const(VariableDefinition) obj) {}
1571 	void exit(const(VariableDefinition) obj) {}
1572 
1573 	void accept(const(VariableDefinition) obj) {
1574 		enter(obj);
1575 		final switch(obj.ruleSelection) {
1576 			case VariableDefinitionEnum.VarD:
1577 				obj.var.visit(this);
1578 				obj.type.visit(this);
1579 				obj.dvalue.visit(this);
1580 				break;
1581 			case VariableDefinitionEnum.Var:
1582 				obj.var.visit(this);
1583 				obj.type.visit(this);
1584 				break;
1585 		}
1586 		exit(obj);
1587 	}
1588 
1589 	void enter(const(Variable) obj) {}
1590 	void exit(const(Variable) obj) {}
1591 
1592 	void accept(const(Variable) obj) {
1593 		enter(obj);
1594 		final switch(obj.ruleSelection) {
1595 			case VariableEnum.Var:
1596 				obj.name.visit(this);
1597 				break;
1598 		}
1599 		exit(obj);
1600 	}
1601 
1602 	void enter(const(DefaultValue) obj) {}
1603 	void exit(const(DefaultValue) obj) {}
1604 
1605 	void accept(const(DefaultValue) obj) {
1606 		enter(obj);
1607 		final switch(obj.ruleSelection) {
1608 			case DefaultValueEnum.DV:
1609 				obj.value.visit(this);
1610 				break;
1611 		}
1612 		exit(obj);
1613 	}
1614 
1615 	void enter(const(ValueOrVariable) obj) {}
1616 	void exit(const(ValueOrVariable) obj) {}
1617 
1618 	void accept(const(ValueOrVariable) obj) {
1619 		enter(obj);
1620 		final switch(obj.ruleSelection) {
1621 			case ValueOrVariableEnum.Val:
1622 				obj.val.visit(this);
1623 				break;
1624 			case ValueOrVariableEnum.Var:
1625 				obj.var.visit(this);
1626 				break;
1627 		}
1628 		exit(obj);
1629 	}
1630 
1631 	void enter(const(Value) obj) {}
1632 	void exit(const(Value) obj) {}
1633 
1634 	void accept(const(Value) obj) {
1635 		enter(obj);
1636 		final switch(obj.ruleSelection) {
1637 			case ValueEnum.STR:
1638 				obj.tok.visit(this);
1639 				break;
1640 			case ValueEnum.INT:
1641 				obj.tok.visit(this);
1642 				break;
1643 			case ValueEnum.FLOAT:
1644 				obj.tok.visit(this);
1645 				break;
1646 			case ValueEnum.T:
1647 				obj.tok.visit(this);
1648 				break;
1649 			case ValueEnum.F:
1650 				obj.tok.visit(this);
1651 				break;
1652 			case ValueEnum.ARR:
1653 				obj.arr.visit(this);
1654 				break;
1655 			case ValueEnum.O:
1656 				obj.obj.visit(this);
1657 				break;
1658 			case ValueEnum.E:
1659 				obj.tok.visit(this);
1660 				break;
1661 		}
1662 		exit(obj);
1663 	}
1664 
1665 	void enter(const(Type) obj) {}
1666 	void exit(const(Type) obj) {}
1667 
1668 	void accept(const(Type) obj) {
1669 		enter(obj);
1670 		final switch(obj.ruleSelection) {
1671 			case TypeEnum.TN:
1672 				obj.tname.visit(this);
1673 				break;
1674 			case TypeEnum.LN:
1675 				obj.list.visit(this);
1676 				break;
1677 			case TypeEnum.T:
1678 				obj.tname.visit(this);
1679 				break;
1680 			case TypeEnum.L:
1681 				obj.list.visit(this);
1682 				break;
1683 		}
1684 		exit(obj);
1685 	}
1686 
1687 	void enter(const(ListType) obj) {}
1688 	void exit(const(ListType) obj) {}
1689 
1690 	void accept(const(ListType) obj) {
1691 		enter(obj);
1692 		final switch(obj.ruleSelection) {
1693 			case ListTypeEnum.T:
1694 				obj.type.visit(this);
1695 				break;
1696 		}
1697 		exit(obj);
1698 	}
1699 
1700 	void enter(const(Values) obj) {}
1701 	void exit(const(Values) obj) {}
1702 
1703 	void accept(const(Values) obj) {
1704 		enter(obj);
1705 		final switch(obj.ruleSelection) {
1706 			case ValuesEnum.Val:
1707 				obj.val.visit(this);
1708 				break;
1709 			case ValuesEnum.Vals:
1710 				obj.val.visit(this);
1711 				obj.follow.visit(this);
1712 				break;
1713 		}
1714 		exit(obj);
1715 	}
1716 
1717 	void enter(const(Array) obj) {}
1718 	void exit(const(Array) obj) {}
1719 
1720 	void accept(const(Array) obj) {
1721 		enter(obj);
1722 		final switch(obj.ruleSelection) {
1723 			case ArrayEnum.Empty:
1724 				break;
1725 			case ArrayEnum.Value:
1726 				obj.vals.visit(this);
1727 				break;
1728 		}
1729 		exit(obj);
1730 	}
1731 
1732 	void enter(const(ObjectValues) obj) {}
1733 	void exit(const(ObjectValues) obj) {}
1734 
1735 	void accept(const(ObjectValues) obj) {
1736 		enter(obj);
1737 		final switch(obj.ruleSelection) {
1738 			case ObjectValuesEnum.V:
1739 				obj.name.visit(this);
1740 				obj.val.visit(this);
1741 				break;
1742 			case ObjectValuesEnum.Vsc:
1743 				obj.name.visit(this);
1744 				obj.val.visit(this);
1745 				obj.follow.visit(this);
1746 				break;
1747 			case ObjectValuesEnum.Vs:
1748 				obj.name.visit(this);
1749 				obj.val.visit(this);
1750 				obj.follow.visit(this);
1751 				break;
1752 		}
1753 		exit(obj);
1754 	}
1755 
1756 	void enter(const(ObjectType) obj) {}
1757 	void exit(const(ObjectType) obj) {}
1758 
1759 	void accept(const(ObjectType) obj) {
1760 		enter(obj);
1761 		final switch(obj.ruleSelection) {
1762 			case ObjectTypeEnum.Var:
1763 				obj.vals.visit(this);
1764 				break;
1765 		}
1766 		exit(obj);
1767 	}
1768 
1769 	void enter(const(TypeSystemDefinition) obj) {}
1770 	void exit(const(TypeSystemDefinition) obj) {}
1771 
1772 	void accept(const(TypeSystemDefinition) obj) {
1773 		enter(obj);
1774 		final switch(obj.ruleSelection) {
1775 			case TypeSystemDefinitionEnum.S:
1776 				obj.sch.visit(this);
1777 				break;
1778 			case TypeSystemDefinitionEnum.T:
1779 				obj.td.visit(this);
1780 				break;
1781 			case TypeSystemDefinitionEnum.TE:
1782 				obj.ted.visit(this);
1783 				break;
1784 			case TypeSystemDefinitionEnum.D:
1785 				obj.dd.visit(this);
1786 				break;
1787 		}
1788 		exit(obj);
1789 	}
1790 
1791 	void enter(const(TypeDefinition) obj) {}
1792 	void exit(const(TypeDefinition) obj) {}
1793 
1794 	void accept(const(TypeDefinition) obj) {
1795 		enter(obj);
1796 		final switch(obj.ruleSelection) {
1797 			case TypeDefinitionEnum.S:
1798 				obj.std.visit(this);
1799 				break;
1800 			case TypeDefinitionEnum.O:
1801 				obj.otd.visit(this);
1802 				break;
1803 			case TypeDefinitionEnum.I:
1804 				obj.itd.visit(this);
1805 				break;
1806 			case TypeDefinitionEnum.U:
1807 				obj.utd.visit(this);
1808 				break;
1809 			case TypeDefinitionEnum.E:
1810 				obj.etd.visit(this);
1811 				break;
1812 			case TypeDefinitionEnum.IO:
1813 				obj.iod.visit(this);
1814 				break;
1815 		}
1816 		exit(obj);
1817 	}
1818 
1819 	void enter(const(SchemaDefinition) obj) {}
1820 	void exit(const(SchemaDefinition) obj) {}
1821 
1822 	void accept(const(SchemaDefinition) obj) {
1823 		enter(obj);
1824 		final switch(obj.ruleSelection) {
1825 			case SchemaDefinitionEnum.DO:
1826 				obj.dir.visit(this);
1827 				obj.otds.visit(this);
1828 				break;
1829 			case SchemaDefinitionEnum.O:
1830 				obj.otds.visit(this);
1831 				break;
1832 		}
1833 		exit(obj);
1834 	}
1835 
1836 	void enter(const(OperationTypeDefinitions) obj) {}
1837 	void exit(const(OperationTypeDefinitions) obj) {}
1838 
1839 	void accept(const(OperationTypeDefinitions) obj) {
1840 		enter(obj);
1841 		final switch(obj.ruleSelection) {
1842 			case OperationTypeDefinitionsEnum.O:
1843 				obj.otd.visit(this);
1844 				break;
1845 			case OperationTypeDefinitionsEnum.OCS:
1846 				obj.otd.visit(this);
1847 				obj.follow.visit(this);
1848 				break;
1849 			case OperationTypeDefinitionsEnum.OS:
1850 				obj.otd.visit(this);
1851 				obj.follow.visit(this);
1852 				break;
1853 		}
1854 		exit(obj);
1855 	}
1856 
1857 	void enter(const(OperationTypeDefinition) obj) {}
1858 	void exit(const(OperationTypeDefinition) obj) {}
1859 
1860 	void accept(const(OperationTypeDefinition) obj) {
1861 		enter(obj);
1862 		final switch(obj.ruleSelection) {
1863 			case OperationTypeDefinitionEnum.O:
1864 				obj.ot.visit(this);
1865 				obj.nt.visit(this);
1866 				break;
1867 		}
1868 		exit(obj);
1869 	}
1870 
1871 	void enter(const(ScalarTypeDefinition) obj) {}
1872 	void exit(const(ScalarTypeDefinition) obj) {}
1873 
1874 	void accept(const(ScalarTypeDefinition) obj) {
1875 		enter(obj);
1876 		final switch(obj.ruleSelection) {
1877 			case ScalarTypeDefinitionEnum.D:
1878 				obj.name.visit(this);
1879 				obj.dir.visit(this);
1880 				break;
1881 			case ScalarTypeDefinitionEnum.S:
1882 				obj.name.visit(this);
1883 				break;
1884 		}
1885 		exit(obj);
1886 	}
1887 
1888 	void enter(const(ObjectTypeDefinition) obj) {}
1889 	void exit(const(ObjectTypeDefinition) obj) {}
1890 
1891 	void accept(const(ObjectTypeDefinition) obj) {
1892 		enter(obj);
1893 		final switch(obj.ruleSelection) {
1894 			case ObjectTypeDefinitionEnum.ID:
1895 				obj.name.visit(this);
1896 				obj.ii.visit(this);
1897 				obj.dir.visit(this);
1898 				obj.fds.visit(this);
1899 				break;
1900 			case ObjectTypeDefinitionEnum.I:
1901 				obj.name.visit(this);
1902 				obj.ii.visit(this);
1903 				obj.fds.visit(this);
1904 				break;
1905 			case ObjectTypeDefinitionEnum.D:
1906 				obj.name.visit(this);
1907 				obj.dir.visit(this);
1908 				obj.fds.visit(this);
1909 				break;
1910 			case ObjectTypeDefinitionEnum.F:
1911 				obj.name.visit(this);
1912 				obj.fds.visit(this);
1913 				break;
1914 		}
1915 		exit(obj);
1916 	}
1917 
1918 	void enter(const(FieldDefinitions) obj) {}
1919 	void exit(const(FieldDefinitions) obj) {}
1920 
1921 	void accept(const(FieldDefinitions) obj) {
1922 		enter(obj);
1923 		final switch(obj.ruleSelection) {
1924 			case FieldDefinitionsEnum.F:
1925 				obj.fd.visit(this);
1926 				break;
1927 			case FieldDefinitionsEnum.FC:
1928 				obj.fd.visit(this);
1929 				obj.follow.visit(this);
1930 				break;
1931 			case FieldDefinitionsEnum.FNC:
1932 				obj.fd.visit(this);
1933 				obj.follow.visit(this);
1934 				break;
1935 		}
1936 		exit(obj);
1937 	}
1938 
1939 	void enter(const(FieldDefinition) obj) {}
1940 	void exit(const(FieldDefinition) obj) {}
1941 
1942 	void accept(const(FieldDefinition) obj) {
1943 		enter(obj);
1944 		final switch(obj.ruleSelection) {
1945 			case FieldDefinitionEnum.AD:
1946 				obj.name.visit(this);
1947 				obj.arg.visit(this);
1948 				obj.typ.visit(this);
1949 				obj.dir.visit(this);
1950 				break;
1951 			case FieldDefinitionEnum.A:
1952 				obj.name.visit(this);
1953 				obj.arg.visit(this);
1954 				obj.typ.visit(this);
1955 				break;
1956 			case FieldDefinitionEnum.D:
1957 				obj.name.visit(this);
1958 				obj.typ.visit(this);
1959 				obj.dir.visit(this);
1960 				break;
1961 			case FieldDefinitionEnum.T:
1962 				obj.name.visit(this);
1963 				obj.typ.visit(this);
1964 				break;
1965 		}
1966 		exit(obj);
1967 	}
1968 
1969 	void enter(const(ImplementsInterfaces) obj) {}
1970 	void exit(const(ImplementsInterfaces) obj) {}
1971 
1972 	void accept(const(ImplementsInterfaces) obj) {
1973 		enter(obj);
1974 		final switch(obj.ruleSelection) {
1975 			case ImplementsInterfacesEnum.N:
1976 				obj.nts.visit(this);
1977 				break;
1978 		}
1979 		exit(obj);
1980 	}
1981 
1982 	void enter(const(NamedTypes) obj) {}
1983 	void exit(const(NamedTypes) obj) {}
1984 
1985 	void accept(const(NamedTypes) obj) {
1986 		enter(obj);
1987 		final switch(obj.ruleSelection) {
1988 			case NamedTypesEnum.N:
1989 				obj.name.visit(this);
1990 				break;
1991 			case NamedTypesEnum.NCS:
1992 				obj.name.visit(this);
1993 				obj.follow.visit(this);
1994 				break;
1995 			case NamedTypesEnum.NS:
1996 				obj.name.visit(this);
1997 				obj.follow.visit(this);
1998 				break;
1999 		}
2000 		exit(obj);
2001 	}
2002 
2003 	void enter(const(ArgumentsDefinition) obj) {}
2004 	void exit(const(ArgumentsDefinition) obj) {}
2005 
2006 	void accept(const(ArgumentsDefinition) obj) {
2007 		enter(obj);
2008 		final switch(obj.ruleSelection) {
2009 			case ArgumentsDefinitionEnum.A:
2010 				break;
2011 		}
2012 		exit(obj);
2013 	}
2014 
2015 	void enter(const(InputValueDefinitions) obj) {}
2016 	void exit(const(InputValueDefinitions) obj) {}
2017 
2018 	void accept(const(InputValueDefinitions) obj) {
2019 		enter(obj);
2020 		final switch(obj.ruleSelection) {
2021 			case InputValueDefinitionsEnum.I:
2022 				obj.iv.visit(this);
2023 				break;
2024 			case InputValueDefinitionsEnum.ICF:
2025 				obj.iv.visit(this);
2026 				obj.follow.visit(this);
2027 				break;
2028 			case InputValueDefinitionsEnum.IF:
2029 				obj.iv.visit(this);
2030 				obj.follow.visit(this);
2031 				break;
2032 		}
2033 		exit(obj);
2034 	}
2035 
2036 	void enter(const(InputValueDefinition) obj) {}
2037 	void exit(const(InputValueDefinition) obj) {}
2038 
2039 	void accept(const(InputValueDefinition) obj) {
2040 		enter(obj);
2041 		final switch(obj.ruleSelection) {
2042 			case InputValueDefinitionEnum.TVD:
2043 				obj.name.visit(this);
2044 				obj.type.visit(this);
2045 				obj.df.visit(this);
2046 				obj.dirs.visit(this);
2047 				break;
2048 			case InputValueDefinitionEnum.TD:
2049 				obj.name.visit(this);
2050 				obj.type.visit(this);
2051 				obj.dirs.visit(this);
2052 				break;
2053 			case InputValueDefinitionEnum.TV:
2054 				obj.name.visit(this);
2055 				obj.type.visit(this);
2056 				obj.df.visit(this);
2057 				break;
2058 			case InputValueDefinitionEnum.T:
2059 				obj.name.visit(this);
2060 				obj.type.visit(this);
2061 				break;
2062 		}
2063 		exit(obj);
2064 	}
2065 
2066 	void enter(const(InterfaceTypeDefinition) obj) {}
2067 	void exit(const(InterfaceTypeDefinition) obj) {}
2068 
2069 	void accept(const(InterfaceTypeDefinition) obj) {
2070 		enter(obj);
2071 		final switch(obj.ruleSelection) {
2072 			case InterfaceTypeDefinitionEnum.NDF:
2073 				obj.name.visit(this);
2074 				obj.dirs.visit(this);
2075 				obj.fds.visit(this);
2076 				break;
2077 			case InterfaceTypeDefinitionEnum.NF:
2078 				obj.name.visit(this);
2079 				obj.fds.visit(this);
2080 				break;
2081 		}
2082 		exit(obj);
2083 	}
2084 
2085 	void enter(const(UnionTypeDefinition) obj) {}
2086 	void exit(const(UnionTypeDefinition) obj) {}
2087 
2088 	void accept(const(UnionTypeDefinition) obj) {
2089 		enter(obj);
2090 		final switch(obj.ruleSelection) {
2091 			case UnionTypeDefinitionEnum.NDU:
2092 				obj.name.visit(this);
2093 				obj.dirs.visit(this);
2094 				obj.um.visit(this);
2095 				break;
2096 			case UnionTypeDefinitionEnum.NU:
2097 				obj.name.visit(this);
2098 				obj.um.visit(this);
2099 				break;
2100 		}
2101 		exit(obj);
2102 	}
2103 
2104 	void enter(const(UnionMembers) obj) {}
2105 	void exit(const(UnionMembers) obj) {}
2106 
2107 	void accept(const(UnionMembers) obj) {
2108 		enter(obj);
2109 		final switch(obj.ruleSelection) {
2110 			case UnionMembersEnum.S:
2111 				obj.name.visit(this);
2112 				break;
2113 			case UnionMembersEnum.SPF:
2114 				obj.name.visit(this);
2115 				obj.follow.visit(this);
2116 				break;
2117 			case UnionMembersEnum.SF:
2118 				obj.name.visit(this);
2119 				obj.follow.visit(this);
2120 				break;
2121 		}
2122 		exit(obj);
2123 	}
2124 
2125 	void enter(const(EnumTypeDefinition) obj) {}
2126 	void exit(const(EnumTypeDefinition) obj) {}
2127 
2128 	void accept(const(EnumTypeDefinition) obj) {
2129 		enter(obj);
2130 		final switch(obj.ruleSelection) {
2131 			case EnumTypeDefinitionEnum.NDE:
2132 				obj.name.visit(this);
2133 				obj.dir.visit(this);
2134 				obj.evds.visit(this);
2135 				break;
2136 			case EnumTypeDefinitionEnum.NE:
2137 				obj.name.visit(this);
2138 				obj.evds.visit(this);
2139 				break;
2140 		}
2141 		exit(obj);
2142 	}
2143 
2144 	void enter(const(EnumValueDefinitions) obj) {}
2145 	void exit(const(EnumValueDefinitions) obj) {}
2146 
2147 	void accept(const(EnumValueDefinitions) obj) {
2148 		enter(obj);
2149 		final switch(obj.ruleSelection) {
2150 			case EnumValueDefinitionsEnum.D:
2151 				obj.evd.visit(this);
2152 				break;
2153 			case EnumValueDefinitionsEnum.DCE:
2154 				obj.evd.visit(this);
2155 				obj.follow.visit(this);
2156 				break;
2157 			case EnumValueDefinitionsEnum.DE:
2158 				obj.evd.visit(this);
2159 				obj.follow.visit(this);
2160 				break;
2161 		}
2162 		exit(obj);
2163 	}
2164 
2165 	void enter(const(EnumValueDefinition) obj) {}
2166 	void exit(const(EnumValueDefinition) obj) {}
2167 
2168 	void accept(const(EnumValueDefinition) obj) {
2169 		enter(obj);
2170 		final switch(obj.ruleSelection) {
2171 			case EnumValueDefinitionEnum.ED:
2172 				obj.name.visit(this);
2173 				obj.dirs.visit(this);
2174 				break;
2175 			case EnumValueDefinitionEnum.E:
2176 				obj.name.visit(this);
2177 				break;
2178 		}
2179 		exit(obj);
2180 	}
2181 
2182 	void enter(const(InputTypeDefinition) obj) {}
2183 	void exit(const(InputTypeDefinition) obj) {}
2184 
2185 	void accept(const(InputTypeDefinition) obj) {
2186 		enter(obj);
2187 		final switch(obj.ruleSelection) {
2188 			case InputTypeDefinitionEnum.NDE:
2189 				obj.name.visit(this);
2190 				obj.dir.visit(this);
2191 				obj.ivds.visit(this);
2192 				break;
2193 			case InputTypeDefinitionEnum.NE:
2194 				obj.name.visit(this);
2195 				obj.ivds.visit(this);
2196 				break;
2197 		}
2198 		exit(obj);
2199 	}
2200 
2201 	void enter(const(TypeExtensionDefinition) obj) {}
2202 	void exit(const(TypeExtensionDefinition) obj) {}
2203 
2204 	void accept(const(TypeExtensionDefinition) obj) {
2205 		enter(obj);
2206 		final switch(obj.ruleSelection) {
2207 			case TypeExtensionDefinitionEnum.O:
2208 				obj.otd.visit(this);
2209 				break;
2210 		}
2211 		exit(obj);
2212 	}
2213 
2214 	void enter(const(DirectiveDefinition) obj) {}
2215 	void exit(const(DirectiveDefinition) obj) {}
2216 
2217 	void accept(const(DirectiveDefinition) obj) {
2218 		enter(obj);
2219 		final switch(obj.ruleSelection) {
2220 			case DirectiveDefinitionEnum.AD:
2221 				obj.name.visit(this);
2222 				obj.ad.visit(this);
2223 				obj.dl.visit(this);
2224 				break;
2225 			case DirectiveDefinitionEnum.D:
2226 				obj.name.visit(this);
2227 				obj.dl.visit(this);
2228 				break;
2229 		}
2230 		exit(obj);
2231 	}
2232 
2233 	void enter(const(DirectiveLocations) obj) {}
2234 	void exit(const(DirectiveLocations) obj) {}
2235 
2236 	void accept(const(DirectiveLocations) obj) {
2237 		enter(obj);
2238 		final switch(obj.ruleSelection) {
2239 			case DirectiveLocationsEnum.N:
2240 				obj.name.visit(this);
2241 				break;
2242 			case DirectiveLocationsEnum.NPF:
2243 				obj.name.visit(this);
2244 				obj.follow.visit(this);
2245 				break;
2246 			case DirectiveLocationsEnum.NF:
2247 				obj.name.visit(this);
2248 				obj.follow.visit(this);
2249 				break;
2250 		}
2251 		exit(obj);
2252 	}
2253 
2254 	void enter(const(InputObjectTypeDefinition) obj) {}
2255 	void exit(const(InputObjectTypeDefinition) obj) {}
2256 
2257 	void accept(const(InputObjectTypeDefinition) obj) {
2258 		enter(obj);
2259 		final switch(obj.ruleSelection) {
2260 			case InputObjectTypeDefinitionEnum.NDI:
2261 				obj.name.visit(this);
2262 				obj.dirs.visit(this);
2263 				break;
2264 			case InputObjectTypeDefinitionEnum.NI:
2265 				obj.name.visit(this);
2266 				break;
2267 		}
2268 		exit(obj);
2269 	}
2270 }
2271

Page generated by adrdox