1 
2 /* Compiler implementation of the D programming language
3  * Copyright (C) 2013-2021 by The D Language Foundation, All Rights Reserved
4  * http://www.digitalmars.com
5  * Distributed under the Boost Software License, Version 1.0.
6  * http://www.boost.org/LICENSE_1_0.txt
7  * https://github.com/dlang/dmd/blob/master/src/dmd/visitor.h
8  */
9 
10 #pragma once
11 
12 #include "root/dsystem.h"
13 
14 class Statement;
15 class ErrorStatement;
16 class PeelStatement;
17 class ExpStatement;
18 class DtorExpStatement;
19 class CompileStatement;
20 class CompoundStatement;
21 class CompoundDeclarationStatement;
22 class UnrolledLoopStatement;
23 class ScopeStatement;
24 class ForwardingStatement;
25 class WhileStatement;
26 class DoStatement;
27 class ForStatement;
28 class ForeachStatement;
29 class ForeachRangeStatement;
30 class StaticForeachStatement;
31 class IfStatement;
32 class ConditionalStatement;
33 class PragmaStatement;
34 class StaticAssertStatement;
35 class SwitchStatement;
36 class CaseStatement;
37 class CaseRangeStatement;
38 class DefaultStatement;
39 class GotoDefaultStatement;
40 class GotoCaseStatement;
41 class SwitchErrorStatement;
42 class ReturnStatement;
43 class BreakStatement;
44 class ContinueStatement;
45 class SynchronizedStatement;
46 class WithStatement;
47 class TryCatchStatement;
48 class TryFinallyStatement;
49 class ScopeGuardStatement;
50 class ThrowStatement;
51 class DebugStatement;
52 class GotoStatement;
53 class LabelStatement;
54 class AsmStatement;
55 class InlineAsmStatement;
56 class GccAsmStatement;
57 class CompoundAsmStatement;
58 class ImportStatement;
59 
60 class Type;
61 class TypeError;
62 class TypeNext;
63 class TypeBasic;
64 class TypeVector;
65 class TypeArray;
66 class TypeSArray;
67 class TypeDArray;
68 class TypeAArray;
69 class TypePointer;
70 class TypeReference;
71 class TypeFunction;
72 class TypeDelegate;
73 class TypeQualified;
74 class TypeIdentifier;
75 class TypeInstance;
76 class TypeTypeof;
77 class TypeReturn;
78 class TypeStruct;
79 class TypeEnum;
80 class TypeClass;
81 class TypeTuple;
82 class TypeSlice;
83 class TypeNull;
84 class TypeNoreturn;
85 class TypeTraits;
86 class TypeMixin;
87 class TypeTag;
88 
89 class Dsymbol;
90 
91 class StaticAssert;
92 class DebugSymbol;
93 class VersionSymbol;
94 class EnumMember;
95 class Import;
96 class OverloadSet;
97 class LabelDsymbol;
98 class AliasThis;
99 
100 class AttribDeclaration;
101 class StorageClassDeclaration;
102 class DeprecatedDeclaration;
103 class LinkDeclaration;
104 class CPPMangleDeclaration;
105 class CPPNamespaceDeclaration;
106 class VisibilityDeclaration;
107 class AlignDeclaration;
108 class AnonDeclaration;
109 class PragmaDeclaration;
110 class ConditionalDeclaration;
111 class StaticIfDeclaration;
112 class CompileDeclaration;
113 class StaticForeachDeclaration;
114 class UserAttributeDeclaration;
115 class ForwardingAttribDeclaration;
116 
117 class ScopeDsymbol;
118 class TemplateDeclaration;
119 class TemplateInstance;
120 class TemplateMixin;
121 class EnumDeclaration;
122 class Package;
123 class Module;
124 class WithScopeSymbol;
125 class ArrayScopeSymbol;
126 class Nspace;
127 class AliasAssign;
128 
129 class AggregateDeclaration;
130 class StructDeclaration;
131 class UnionDeclaration;
132 class ClassDeclaration;
133 class InterfaceDeclaration;
134 
135 class Declaration;
136 class TupleDeclaration;
137 class AliasDeclaration;
138 class OverDeclaration;
139 class VarDeclaration;
140 class SymbolDeclaration;
141 class ThisDeclaration;
142 class BitFieldDeclaration;
143 
144 class TypeInfoDeclaration;
145 class TypeInfoStructDeclaration;
146 class TypeInfoClassDeclaration;
147 class TypeInfoInterfaceDeclaration;
148 class TypeInfoPointerDeclaration;
149 class TypeInfoArrayDeclaration;
150 class TypeInfoStaticArrayDeclaration;
151 class TypeInfoAssociativeArrayDeclaration;
152 class TypeInfoEnumDeclaration;
153 class TypeInfoFunctionDeclaration;
154 class TypeInfoDelegateDeclaration;
155 class TypeInfoTupleDeclaration;
156 class TypeInfoConstDeclaration;
157 class TypeInfoInvariantDeclaration;
158 class TypeInfoSharedDeclaration;
159 class TypeInfoWildDeclaration;
160 class TypeInfoVectorDeclaration;
161 
162 class FuncDeclaration;
163 class FuncAliasDeclaration;
164 class FuncLiteralDeclaration;
165 class CtorDeclaration;
166 class PostBlitDeclaration;
167 class DtorDeclaration;
168 class StaticCtorDeclaration;
169 class SharedStaticCtorDeclaration;
170 class StaticDtorDeclaration;
171 class SharedStaticDtorDeclaration;
172 class InvariantDeclaration;
173 class UnitTestDeclaration;
174 class NewDeclaration;
175 
176 class Initializer;
177 class VoidInitializer;
178 class ErrorInitializer;
179 class StructInitializer;
180 class ArrayInitializer;
181 class ExpInitializer;
182 class CInitializer;
183 
184 class Expression;
185 class IntegerExp;
186 class ErrorExp;
187 class RealExp;
188 class ComplexExp;
189 class IdentifierExp;
190 class DollarExp;
191 class DsymbolExp;
192 class ThisExp;
193 class SuperExp;
194 class NullExp;
195 class StringExp;
196 class TupleExp;
197 class ArrayLiteralExp;
198 class AssocArrayLiteralExp;
199 class StructLiteralExp;
200 class CompoundLiteralExp;
201 class ObjcClassReferenceExp;
202 class TypeExp;
203 class ScopeExp;
204 class TemplateExp;
205 class NewExp;
206 class NewAnonClassExp;
207 class SymbolExp;
208 class SymOffExp;
209 class VarExp;
210 class OverExp;
211 class FuncExp;
212 class DeclarationExp;
213 class TypeidExp;
214 class TraitsExp;
215 class HaltExp;
216 class IsExp;
217 class UnaExp;
218 class BinExp;
219 class BinAssignExp;
220 class MixinExp;
221 class ImportExp;
222 class AssertExp;
223 class DotIdExp;
224 class DotTemplateExp;
225 class DotVarExp;
226 class DotTemplateInstanceExp;
227 class DelegateExp;
228 class DotTypeExp;
229 class CallExp;
230 class AddrExp;
231 class PtrExp;
232 class NegExp;
233 class UAddExp;
234 class ComExp;
235 class NotExp;
236 class DeleteExp;
237 class CastExp;
238 class VectorExp;
239 class VectorArrayExp;
240 class SliceExp;
241 class ArrayLengthExp;
242 class IntervalExp;
243 class DelegatePtrExp;
244 class DelegateFuncptrExp;
245 class ArrayExp;
246 class DotExp;
247 class CommaExp;
248 class IndexExp;
249 class PostExp;
250 class PreExp;
251 class AssignExp;
252 class ConstructExp;
253 class BlitExp;
254 class AddAssignExp;
255 class MinAssignExp;
256 class MulAssignExp;
257 class DivAssignExp;
258 class ModAssignExp;
259 class AndAssignExp;
260 class OrAssignExp;
261 class XorAssignExp;
262 class PowAssignExp;
263 class ShlAssignExp;
264 class ShrAssignExp;
265 class UshrAssignExp;
266 class CatAssignExp;
267 class AddExp;
268 class MinExp;
269 class CatExp;
270 class MulExp;
271 class DivExp;
272 class ModExp;
273 class PowExp;
274 class ShlExp;
275 class ShrExp;
276 class UshrExp;
277 class AndExp;
278 class OrExp;
279 class XorExp;
280 class LogicalExp;
281 class CmpExp;
282 class InExp;
283 class RemoveExp;
284 class EqualExp;
285 class IdentityExp;
286 class CondExp;
287 class DefaultInitExp;
288 class FileInitExp;
289 class LineInitExp;
290 class ModuleInitExp;
291 class FuncInitExp;
292 class PrettyFuncInitExp;
293 class ClassReferenceExp;
294 class VoidInitExp;
295 class ThrownExceptionExp;
296 class GenericExp;
297 
298 class TemplateParameter;
299 class TemplateTypeParameter;
300 class TemplateThisParameter;
301 class TemplateValueParameter;
302 class TemplateAliasParameter;
303 class TemplateTupleParameter;
304 
305 class Condition;
306 class DVCondition;
307 class DebugCondition;
308 class VersionCondition;
309 class StaticIfCondition;
310 
311 class Parameter;
312 
313 class ParseTimeVisitor
314 {
315 public:
visit(Dsymbol *)316     virtual void visit(Dsymbol *) { assert(0); }
visit(Parameter *)317     virtual void visit(Parameter *) { assert(0); }
visit(Statement *)318     virtual void visit(Statement *) { assert(0); }
visit(Type *)319     virtual void visit(Type *) { assert(0); }
visit(Expression *)320     virtual void visit(Expression *) { assert(0); }
visit(TemplateParameter *)321     virtual void visit(TemplateParameter *) { assert(0); }
visit(Condition *)322     virtual void visit(Condition *) { assert(0); }
visit(Initializer *)323     virtual void visit(Initializer *) { assert(0); }
324 
325     // Dsymbols
visit(AliasThis * s)326     virtual void visit(AliasThis *s) { visit((Dsymbol *)s); }
visit(Declaration * s)327     virtual void visit(Declaration *s) { visit((Dsymbol *)s); }
visit(ScopeDsymbol * s)328     virtual void visit(ScopeDsymbol *s) { visit((Dsymbol *)s); }
visit(Import * s)329     virtual void visit(Import *s) { visit((Dsymbol *)s); }
visit(AttribDeclaration * s)330     virtual void visit(AttribDeclaration *s) { visit((Dsymbol *)s); }
visit(StaticAssert * s)331     virtual void visit(StaticAssert *s) { visit((Dsymbol *)s); }
visit(DebugSymbol * s)332     virtual void visit(DebugSymbol *s) { visit((Dsymbol *)s); }
visit(VersionSymbol * s)333     virtual void visit(VersionSymbol *s) { visit((Dsymbol *)s); }
visit(AliasAssign * s)334     virtual void visit(AliasAssign *s) { visit((Dsymbol *)s); }
335 
336     // ScopeDsymbols
visit(Package * s)337     virtual void visit(Package *s) { visit((ScopeDsymbol *)s); }
visit(EnumDeclaration * s)338     virtual void visit(EnumDeclaration *s) { visit((ScopeDsymbol *)s); }
visit(AggregateDeclaration * s)339     virtual void visit(AggregateDeclaration *s) { visit((ScopeDsymbol *)s); }
visit(TemplateDeclaration * s)340     virtual void visit(TemplateDeclaration *s) { visit((ScopeDsymbol *)s); }
visit(TemplateInstance * s)341     virtual void visit(TemplateInstance *s) { visit((ScopeDsymbol *)s); }
visit(Nspace * s)342     virtual void visit(Nspace *s) { visit((ScopeDsymbol *)s); }
343 
344     // Declarations
visit(VarDeclaration * s)345     virtual void visit(VarDeclaration *s) { visit((Declaration *)s); }
visit(FuncDeclaration * s)346     virtual void visit(FuncDeclaration *s) { visit((Declaration *)s); }
visit(AliasDeclaration * s)347     virtual void visit(AliasDeclaration *s) { visit((Declaration *)s); }
visit(TupleDeclaration * s)348     virtual void visit(TupleDeclaration *s) { visit((Declaration *)s); }
349 
350     // FuncDeclarations
visit(FuncLiteralDeclaration * s)351     virtual void visit(FuncLiteralDeclaration *s) { visit((FuncDeclaration *)s); }
visit(PostBlitDeclaration * s)352     virtual void visit(PostBlitDeclaration *s) { visit((FuncDeclaration *)s); }
visit(CtorDeclaration * s)353     virtual void visit(CtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(DtorDeclaration * s)354     virtual void visit(DtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(InvariantDeclaration * s)355     virtual void visit(InvariantDeclaration *s) { visit((FuncDeclaration *)s); }
visit(UnitTestDeclaration * s)356     virtual void visit(UnitTestDeclaration *s) { visit((FuncDeclaration *)s); }
visit(NewDeclaration * s)357     virtual void visit(NewDeclaration *s) { visit((FuncDeclaration *)s); }
visit(StaticCtorDeclaration * s)358     virtual void visit(StaticCtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(StaticDtorDeclaration * s)359     virtual void visit(StaticDtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(SharedStaticCtorDeclaration * s)360     virtual void visit(SharedStaticCtorDeclaration *s) { visit((StaticCtorDeclaration *)s); }
visit(SharedStaticDtorDeclaration * s)361     virtual void visit(SharedStaticDtorDeclaration *s) { visit((StaticDtorDeclaration *)s); }
362 
363     // AttribDeclarations
visit(CompileDeclaration * s)364     virtual void visit(CompileDeclaration *s) { visit((AttribDeclaration *)s); }
visit(UserAttributeDeclaration * s)365     virtual void visit(UserAttributeDeclaration *s) { visit((AttribDeclaration *)s); }
visit(LinkDeclaration * s)366     virtual void visit(LinkDeclaration *s) { visit((AttribDeclaration *)s); }
visit(AnonDeclaration * s)367     virtual void visit(AnonDeclaration *s) { visit((AttribDeclaration *)s); }
visit(AlignDeclaration * s)368     virtual void visit(AlignDeclaration *s) { visit((AttribDeclaration *)s); }
visit(CPPMangleDeclaration * s)369     virtual void visit(CPPMangleDeclaration *s) { visit((AttribDeclaration *)s); }
visit(CPPNamespaceDeclaration * s)370     virtual void visit(CPPNamespaceDeclaration *s) { visit((AttribDeclaration *)s); }
visit(VisibilityDeclaration * s)371     virtual void visit(VisibilityDeclaration *s) { visit((AttribDeclaration *)s); }
visit(PragmaDeclaration * s)372     virtual void visit(PragmaDeclaration *s) { visit((AttribDeclaration *)s); }
visit(StorageClassDeclaration * s)373     virtual void visit(StorageClassDeclaration *s) { visit((AttribDeclaration *)s); }
visit(ConditionalDeclaration * s)374     virtual void visit(ConditionalDeclaration *s) { visit((AttribDeclaration *)s); }
visit(StaticForeachDeclaration * s)375     virtual void visit(StaticForeachDeclaration *s) { visit((AttribDeclaration *)s); }
376 
377     // Miscellaneous
visit(DeprecatedDeclaration * s)378     virtual void visit(DeprecatedDeclaration *s) { visit((StorageClassDeclaration *)s); }
visit(StaticIfDeclaration * s)379     virtual void visit(StaticIfDeclaration *s) { visit((ConditionalDeclaration *)s); }
visit(EnumMember * s)380     virtual void visit(EnumMember *s) { visit((VarDeclaration *)s); }
visit(Module * s)381     virtual void visit(Module *s) { visit((Package *)s); }
visit(StructDeclaration * s)382     virtual void visit(StructDeclaration *s) { visit((AggregateDeclaration *)s); }
visit(UnionDeclaration * s)383     virtual void visit(UnionDeclaration *s) { visit((StructDeclaration *)s); }
visit(ClassDeclaration * s)384     virtual void visit(ClassDeclaration *s) { visit((AggregateDeclaration *)s); }
visit(InterfaceDeclaration * s)385     virtual void visit(InterfaceDeclaration *s) { visit((ClassDeclaration *)s); }
visit(TemplateMixin * s)386     virtual void visit(TemplateMixin *s) { visit((TemplateInstance *)s); }
visit(BitFieldDeclaration * s)387     virtual void visit(BitFieldDeclaration *s) { visit((VarDeclaration *)s); }
388 
389     // Statements
visit(ImportStatement * s)390     virtual void visit(ImportStatement *s) { visit((Statement *)s); }
visit(ScopeStatement * s)391     virtual void visit(ScopeStatement *s) { visit((Statement *)s); }
visit(ReturnStatement * s)392     virtual void visit(ReturnStatement *s) { visit((Statement *)s); }
visit(LabelStatement * s)393     virtual void visit(LabelStatement *s) { visit((Statement *)s); }
visit(StaticAssertStatement * s)394     virtual void visit(StaticAssertStatement *s) { visit((Statement *)s); }
visit(CompileStatement * s)395     virtual void visit(CompileStatement *s) { visit((Statement *)s); }
visit(WhileStatement * s)396     virtual void visit(WhileStatement *s) { visit((Statement *)s); }
visit(ForStatement * s)397     virtual void visit(ForStatement *s) { visit((Statement *)s); }
visit(DoStatement * s)398     virtual void visit(DoStatement *s) { visit((Statement *)s); }
visit(ForeachRangeStatement * s)399     virtual void visit(ForeachRangeStatement *s) { visit((Statement *)s); }
visit(ForeachStatement * s)400     virtual void visit(ForeachStatement *s) { visit((Statement *)s); }
visit(IfStatement * s)401     virtual void visit(IfStatement *s) { visit((Statement *)s); }
visit(ScopeGuardStatement * s)402     virtual void visit(ScopeGuardStatement *s) { visit((Statement *)s); }
visit(ConditionalStatement * s)403     virtual void visit(ConditionalStatement *s) { visit((Statement *)s); }
visit(StaticForeachStatement * s)404     virtual void visit(StaticForeachStatement *s) { visit((Statement *)s); }
visit(PragmaStatement * s)405     virtual void visit(PragmaStatement *s) { visit((Statement *)s); }
visit(SwitchStatement * s)406     virtual void visit(SwitchStatement *s) { visit((Statement *)s); }
visit(CaseRangeStatement * s)407     virtual void visit(CaseRangeStatement *s) { visit((Statement *)s); }
visit(CaseStatement * s)408     virtual void visit(CaseStatement *s) { visit((Statement *)s); }
visit(DefaultStatement * s)409     virtual void visit(DefaultStatement *s) { visit((Statement *)s); }
visit(BreakStatement * s)410     virtual void visit(BreakStatement *s) { visit((Statement *)s); }
visit(ContinueStatement * s)411     virtual void visit(ContinueStatement *s) { visit((Statement *)s); }
visit(GotoDefaultStatement * s)412     virtual void visit(GotoDefaultStatement *s) { visit((Statement *)s); }
visit(GotoCaseStatement * s)413     virtual void visit(GotoCaseStatement *s) { visit((Statement *)s); }
visit(GotoStatement * s)414     virtual void visit(GotoStatement *s) { visit((Statement *)s); }
visit(SynchronizedStatement * s)415     virtual void visit(SynchronizedStatement *s) { visit((Statement *)s); }
visit(WithStatement * s)416     virtual void visit(WithStatement *s) { visit((Statement *)s); }
visit(TryCatchStatement * s)417     virtual void visit(TryCatchStatement *s) { visit((Statement *)s); }
visit(TryFinallyStatement * s)418     virtual void visit(TryFinallyStatement *s) { visit((Statement *)s); }
visit(ThrowStatement * s)419     virtual void visit(ThrowStatement *s) { visit((Statement *)s); }
visit(AsmStatement * s)420     virtual void visit(AsmStatement *s) { visit((Statement *)s); }
visit(ExpStatement * s)421     virtual void visit(ExpStatement *s) { visit((Statement *)s); }
visit(CompoundStatement * s)422     virtual void visit(CompoundStatement *s) { visit((Statement *)s); }
423 
424     // CompoundStatements
visit(CompoundDeclarationStatement * s)425     virtual void visit(CompoundDeclarationStatement *s) { visit((CompoundStatement *)s); }
visit(CompoundAsmStatement * s)426     virtual void visit(CompoundAsmStatement *s) { visit((CompoundStatement *)s); }
427 
428     // AsmStatements
visit(InlineAsmStatement * s)429     virtual void visit(InlineAsmStatement *s) { visit((AsmStatement *)s); }
visit(GccAsmStatement * s)430     virtual void visit(GccAsmStatement *s) { visit((AsmStatement *)s); }
431 
432     // Types
visit(TypeBasic * t)433     virtual void visit(TypeBasic *t) { visit((Type *)t); }
visit(TypeError * t)434     virtual void visit(TypeError *t) { visit((Type *)t); }
visit(TypeNull * t)435     virtual void visit(TypeNull *t) { visit((Type *)t); }
visit(TypeNoreturn * t)436     virtual void visit(TypeNoreturn *t) { visit((Type *)t); }
visit(TypeVector * t)437     virtual void visit(TypeVector *t) { visit((Type *)t); }
visit(TypeEnum * t)438     virtual void visit(TypeEnum *t) { visit((Type *)t); }
visit(TypeTuple * t)439     virtual void visit(TypeTuple *t) { visit((Type *)t); }
visit(TypeClass * t)440     virtual void visit(TypeClass *t) { visit((Type *)t); }
visit(TypeStruct * t)441     virtual void visit(TypeStruct *t) { visit((Type *)t); }
visit(TypeNext * t)442     virtual void visit(TypeNext *t) { visit((Type *)t); }
visit(TypeQualified * t)443     virtual void visit(TypeQualified *t) { visit((Type *)t); }
visit(TypeTraits * t)444     virtual void visit(TypeTraits *t) { visit((Type *)t); }
visit(TypeMixin * t)445     virtual void visit(TypeMixin *t) { visit((Type *)t); }
visit(TypeTag * t)446     virtual void visit(TypeTag *t) { visit((Type *)t); }
447 
448     // TypeNext
visit(TypeReference * t)449     virtual void visit(TypeReference *t) { visit((TypeNext *)t); }
visit(TypeSlice * t)450     virtual void visit(TypeSlice *t) { visit((TypeNext *)t); }
visit(TypeDelegate * t)451     virtual void visit(TypeDelegate *t) { visit((TypeNext *)t); }
visit(TypePointer * t)452     virtual void visit(TypePointer *t) { visit((TypeNext *)t); }
visit(TypeFunction * t)453     virtual void visit(TypeFunction *t) { visit((TypeNext *)t); }
visit(TypeArray * t)454     virtual void visit(TypeArray *t) { visit((TypeNext *)t); }
455 
456     // TypeArray
visit(TypeDArray * t)457     virtual void visit(TypeDArray *t) { visit((TypeArray *)t); }
visit(TypeAArray * t)458     virtual void visit(TypeAArray *t) { visit((TypeArray *)t); }
visit(TypeSArray * t)459     virtual void visit(TypeSArray *t) { visit((TypeArray *)t); }
460 
461     // TypeQualified
visit(TypeIdentifier * t)462     virtual void visit(TypeIdentifier *t) { visit((TypeQualified *)t); }
visit(TypeReturn * t)463     virtual void visit(TypeReturn *t) { visit((TypeQualified *)t); }
visit(TypeTypeof * t)464     virtual void visit(TypeTypeof *t) { visit((TypeQualified *)t); }
visit(TypeInstance * t)465     virtual void visit(TypeInstance *t) { visit((TypeQualified *)t); }
466 
467     // Expressions
visit(DeclarationExp * e)468     virtual void visit(DeclarationExp *e) { visit((Expression *)e); }
visit(IntegerExp * e)469     virtual void visit(IntegerExp *e) { visit((Expression *)e); }
visit(NewAnonClassExp * e)470     virtual void visit(NewAnonClassExp *e) { visit((Expression *)e); }
visit(IsExp * e)471     virtual void visit(IsExp *e) { visit((Expression *)e); }
visit(RealExp * e)472     virtual void visit(RealExp *e) { visit((Expression *)e); }
visit(NullExp * e)473     virtual void visit(NullExp *e) { visit((Expression *)e); }
visit(TypeidExp * e)474     virtual void visit(TypeidExp *e) { visit((Expression *)e); }
visit(TraitsExp * e)475     virtual void visit(TraitsExp *e) { visit((Expression *)e); }
visit(StringExp * e)476     virtual void visit(StringExp *e) { visit((Expression *)e); }
visit(NewExp * e)477     virtual void visit(NewExp *e) { visit((Expression *)e); }
visit(AssocArrayLiteralExp * e)478     virtual void visit(AssocArrayLiteralExp *e) { visit((Expression *)e); }
visit(ArrayLiteralExp * e)479     virtual void visit(ArrayLiteralExp *e) { visit((Expression *)e); }
visit(MixinExp * e)480     virtual void visit(MixinExp *e) { visit((Expression *)e); }
visit(FuncExp * e)481     virtual void visit(FuncExp *e) { visit((Expression *)e); }
visit(IntervalExp * e)482     virtual void visit(IntervalExp *e) { visit((Expression *)e); }
visit(TypeExp * e)483     virtual void visit(TypeExp *e) { visit((Expression *)e); }
visit(ScopeExp * e)484     virtual void visit(ScopeExp *e) { visit((Expression *)e); }
visit(IdentifierExp * e)485     virtual void visit(IdentifierExp *e) { visit((Expression *)e); }
visit(UnaExp * e)486     virtual void visit(UnaExp *e) { visit((Expression *)e); }
visit(DefaultInitExp * e)487     virtual void visit(DefaultInitExp *e) { visit((Expression *)e); }
visit(BinExp * e)488     virtual void visit(BinExp *e) { visit((Expression *)e); }
visit(DsymbolExp * e)489     virtual void visit(DsymbolExp *e) { visit((Expression *)e); }
visit(TemplateExp * e)490     virtual void visit(TemplateExp *e) { visit((Expression *)e); }
visit(SymbolExp * e)491     virtual void visit(SymbolExp *e) { visit((Expression *)e); }
visit(TupleExp * e)492     virtual void visit(TupleExp *e) { visit((Expression *)e); }
visit(ThisExp * e)493     virtual void visit(ThisExp *e) { visit((Expression *)e); }
visit(GenericExp * e)494     virtual void visit(GenericExp *e) { visit((Expression *)e); }
495 
496     // Miscellaneous
visit(VarExp * e)497     virtual void visit(VarExp *e) { visit((SymbolExp *)e); }
visit(DollarExp * e)498     virtual void visit(DollarExp *e) { visit((IdentifierExp *)e); }
visit(SuperExp * e)499     virtual void visit(SuperExp *e) { visit((ThisExp *)e); }
500 
501     // UnaExp
visit(AddrExp * e)502     virtual void visit(AddrExp *e) { visit((UnaExp *)e); }
visit(PreExp * e)503     virtual void visit(PreExp *e) { visit((UnaExp *)e); }
visit(PtrExp * e)504     virtual void visit(PtrExp *e) { visit((UnaExp *)e); }
visit(NegExp * e)505     virtual void visit(NegExp *e) { visit((UnaExp *)e); }
visit(UAddExp * e)506     virtual void visit(UAddExp *e) { visit((UnaExp *)e); }
visit(NotExp * e)507     virtual void visit(NotExp *e) { visit((UnaExp *)e); }
visit(ComExp * e)508     virtual void visit(ComExp *e) { visit((UnaExp *)e); }
visit(DeleteExp * e)509     virtual void visit(DeleteExp *e) { visit((UnaExp *)e); }
visit(CastExp * e)510     virtual void visit(CastExp *e) { visit((UnaExp *)e); }
visit(CallExp * e)511     virtual void visit(CallExp *e) { visit((UnaExp *)e); }
visit(DotIdExp * e)512     virtual void visit(DotIdExp *e) { visit((UnaExp *)e); }
visit(AssertExp * e)513     virtual void visit(AssertExp *e) { visit((UnaExp *)e); }
visit(ImportExp * e)514     virtual void visit(ImportExp *e) { visit((UnaExp *)e); }
visit(DotTemplateInstanceExp * e)515     virtual void visit(DotTemplateInstanceExp *e) { visit((UnaExp *)e); }
visit(ArrayExp * e)516     virtual void visit(ArrayExp *e) { visit((UnaExp *)e); }
517 
518     // DefaultInitExp
visit(FuncInitExp * e)519     virtual void visit(FuncInitExp *e) { visit((DefaultInitExp *)e); }
visit(PrettyFuncInitExp * e)520     virtual void visit(PrettyFuncInitExp *e) { visit((DefaultInitExp *)e); }
visit(FileInitExp * e)521     virtual void visit(FileInitExp *e) { visit((DefaultInitExp *)e); }
visit(LineInitExp * e)522     virtual void visit(LineInitExp *e) { visit((DefaultInitExp *)e); }
visit(ModuleInitExp * e)523     virtual void visit(ModuleInitExp *e) { visit((DefaultInitExp *)e); }
524 
525     // BinExp
visit(CommaExp * e)526     virtual void visit(CommaExp *e) { visit((BinExp *)e); }
visit(PostExp * e)527     virtual void visit(PostExp *e) { visit((BinExp *)e); }
visit(PowExp * e)528     virtual void visit(PowExp *e) { visit((BinExp *)e); }
visit(MulExp * e)529     virtual void visit(MulExp *e) { visit((BinExp *)e); }
visit(DivExp * e)530     virtual void visit(DivExp *e) { visit((BinExp *)e); }
visit(ModExp * e)531     virtual void visit(ModExp *e) { visit((BinExp *)e); }
visit(AddExp * e)532     virtual void visit(AddExp *e) { visit((BinExp *)e); }
visit(MinExp * e)533     virtual void visit(MinExp *e) { visit((BinExp *)e); }
visit(CatExp * e)534     virtual void visit(CatExp *e) { visit((BinExp *)e); }
visit(ShlExp * e)535     virtual void visit(ShlExp *e) { visit((BinExp *)e); }
visit(ShrExp * e)536     virtual void visit(ShrExp *e) { visit((BinExp *)e); }
visit(UshrExp * e)537     virtual void visit(UshrExp *e) { visit((BinExp *)e); }
visit(EqualExp * e)538     virtual void visit(EqualExp *e) { visit((BinExp *)e); }
visit(InExp * e)539     virtual void visit(InExp *e) { visit((BinExp *)e); }
visit(IdentityExp * e)540     virtual void visit(IdentityExp *e) { visit((BinExp *)e); }
visit(CmpExp * e)541     virtual void visit(CmpExp *e) { visit((BinExp *)e); }
visit(AndExp * e)542     virtual void visit(AndExp *e) { visit((BinExp *)e); }
visit(XorExp * e)543     virtual void visit(XorExp *e) { visit((BinExp *)e); }
visit(OrExp * e)544     virtual void visit(OrExp *e) { visit((BinExp *)e); }
visit(LogicalExp * e)545     virtual void visit(LogicalExp *e) { visit((BinExp *)e); }
visit(CondExp * e)546     virtual void visit(CondExp *e) { visit((BinExp *)e); }
visit(AssignExp * e)547     virtual void visit(AssignExp *e) { visit((BinExp *)e); }
visit(BinAssignExp * e)548     virtual void visit(BinAssignExp *e) { visit((BinExp *)e); }
549 
550     // BinAssignExp
visit(AddAssignExp * e)551     virtual void visit(AddAssignExp *e) { visit((BinAssignExp *)e); }
visit(MinAssignExp * e)552     virtual void visit(MinAssignExp *e) { visit((BinAssignExp *)e); }
visit(MulAssignExp * e)553     virtual void visit(MulAssignExp *e) { visit((BinAssignExp *)e); }
visit(DivAssignExp * e)554     virtual void visit(DivAssignExp *e) { visit((BinAssignExp *)e); }
visit(ModAssignExp * e)555     virtual void visit(ModAssignExp *e) { visit((BinAssignExp *)e); }
visit(PowAssignExp * e)556     virtual void visit(PowAssignExp *e) { visit((BinAssignExp *)e); }
visit(AndAssignExp * e)557     virtual void visit(AndAssignExp *e) { visit((BinAssignExp *)e); }
visit(OrAssignExp * e)558     virtual void visit(OrAssignExp *e) { visit((BinAssignExp *)e); }
visit(XorAssignExp * e)559     virtual void visit(XorAssignExp *e) { visit((BinAssignExp *)e); }
visit(ShlAssignExp * e)560     virtual void visit(ShlAssignExp *e) { visit((BinAssignExp *)e); }
visit(ShrAssignExp * e)561     virtual void visit(ShrAssignExp *e) { visit((BinAssignExp *)e); }
visit(UshrAssignExp * e)562     virtual void visit(UshrAssignExp *e) { visit((BinAssignExp *)e); }
visit(CatAssignExp * e)563     virtual void visit(CatAssignExp *e) { visit((BinAssignExp *)e); }
564 
565     // TemplateParameter
visit(TemplateAliasParameter * tp)566     virtual void visit(TemplateAliasParameter *tp) { visit((TemplateParameter *)tp); }
visit(TemplateTypeParameter * tp)567     virtual void visit(TemplateTypeParameter *tp) { visit((TemplateParameter *)tp); }
visit(TemplateTupleParameter * tp)568     virtual void visit(TemplateTupleParameter *tp) { visit((TemplateParameter *)tp); }
visit(TemplateValueParameter * tp)569     virtual void visit(TemplateValueParameter *tp) { visit((TemplateParameter *)tp); }
570 
visit(TemplateThisParameter * tp)571     virtual void visit(TemplateThisParameter *tp) { visit((TemplateTypeParameter *)tp); }
572 
573     // Condition
visit(StaticIfCondition * c)574     virtual void visit(StaticIfCondition *c) { visit((Condition *)c); }
visit(DVCondition * c)575     virtual void visit(DVCondition *c) { visit((Condition *)c); }
visit(DebugCondition * c)576     virtual void visit(DebugCondition *c) { visit((DVCondition *)c); }
visit(VersionCondition * c)577     virtual void visit(VersionCondition *c) { visit((DVCondition *)c); }
578 
579     // Initializer
visit(ExpInitializer * i)580     virtual void visit(ExpInitializer *i) { visit((Initializer *)i); }
visit(StructInitializer * i)581     virtual void visit(StructInitializer *i) { visit((Initializer *)i); }
visit(ArrayInitializer * i)582     virtual void visit(ArrayInitializer *i) { visit((Initializer *)i); }
visit(VoidInitializer * i)583     virtual void visit(VoidInitializer *i) { visit((Initializer *)i); }
visit(CInitializer * i)584     virtual void visit(CInitializer *i) { visit((Initializer *)i); }
585 };
586 
587 class Visitor : public ParseTimeVisitor
588 {
589 public:
590     using ParseTimeVisitor::visit;
591 
592     // Miscellaneous
visit(ErrorStatement * s)593     virtual void visit(ErrorStatement *s) { visit((Statement *)s); }
visit(PeelStatement * s)594     virtual void visit(PeelStatement *s) { visit((Statement *)s); }
visit(UnrolledLoopStatement * s)595     virtual void visit(UnrolledLoopStatement *s) { visit((Statement *)s); }
visit(SwitchErrorStatement * s)596     virtual void visit(SwitchErrorStatement *s) { visit((Statement *)s); }
visit(DebugStatement * s)597     virtual void visit(DebugStatement *s) { visit((Statement *)s); }
visit(DtorExpStatement * s)598     virtual void visit(DtorExpStatement *s) { visit((ExpStatement *)s); }
visit(ForwardingStatement * s)599     virtual void visit(ForwardingStatement *s) { visit((Statement *)s); }
visit(OverloadSet * s)600     virtual void visit(OverloadSet *s) { visit((Dsymbol *)s); }
visit(LabelDsymbol * s)601     virtual void visit(LabelDsymbol *s) { visit((Dsymbol *)s); }
visit(WithScopeSymbol * s)602     virtual void visit(WithScopeSymbol *s) { visit((ScopeDsymbol *)s); }
visit(ArrayScopeSymbol * s)603     virtual void visit(ArrayScopeSymbol *s) { visit((ScopeDsymbol *)s); }
visit(OverDeclaration * s)604     virtual void visit(OverDeclaration *s) { visit((Declaration *)s); }
visit(SymbolDeclaration * s)605     virtual void visit(SymbolDeclaration *s) { visit((Declaration *)s); }
visit(ForwardingAttribDeclaration * s)606     virtual void visit(ForwardingAttribDeclaration *s) { visit((AttribDeclaration *)s); }
visit(ThisDeclaration * s)607     virtual void visit(ThisDeclaration *s) { visit((VarDeclaration *)s); }
visit(TypeInfoDeclaration * s)608     virtual void visit(TypeInfoDeclaration *s) { visit((VarDeclaration *)s); }
visit(TypeInfoStructDeclaration * s)609     virtual void visit(TypeInfoStructDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoClassDeclaration * s)610     virtual void visit(TypeInfoClassDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoInterfaceDeclaration * s)611     virtual void visit(TypeInfoInterfaceDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoPointerDeclaration * s)612     virtual void visit(TypeInfoPointerDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoArrayDeclaration * s)613     virtual void visit(TypeInfoArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoStaticArrayDeclaration * s)614     virtual void visit(TypeInfoStaticArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoAssociativeArrayDeclaration * s)615     virtual void visit(TypeInfoAssociativeArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoEnumDeclaration * s)616     virtual void visit(TypeInfoEnumDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoFunctionDeclaration * s)617     virtual void visit(TypeInfoFunctionDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoDelegateDeclaration * s)618     virtual void visit(TypeInfoDelegateDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoTupleDeclaration * s)619     virtual void visit(TypeInfoTupleDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoConstDeclaration * s)620     virtual void visit(TypeInfoConstDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoInvariantDeclaration * s)621     virtual void visit(TypeInfoInvariantDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoSharedDeclaration * s)622     virtual void visit(TypeInfoSharedDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoWildDeclaration * s)623     virtual void visit(TypeInfoWildDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoVectorDeclaration * s)624     virtual void visit(TypeInfoVectorDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(FuncAliasDeclaration * s)625     virtual void visit(FuncAliasDeclaration *s) { visit((FuncDeclaration *)s); }
visit(ErrorInitializer * i)626     virtual void visit(ErrorInitializer *i) { visit((Initializer *)i); }
visit(ErrorExp * e)627     virtual void visit(ErrorExp *e) { visit((Expression *)e); }
visit(ComplexExp * e)628     virtual void visit(ComplexExp *e) { visit((Expression *)e); }
visit(StructLiteralExp * e)629     virtual void visit(StructLiteralExp *e) { visit((Expression *)e); }
visit(CompoundLiteralExp * e)630     virtual void visit(CompoundLiteralExp *e) { visit((Expression *)e); }
visit(ObjcClassReferenceExp * e)631     virtual void visit(ObjcClassReferenceExp *e) { visit((Expression *)e); }
visit(SymOffExp * e)632     virtual void visit(SymOffExp *e) { visit((SymbolExp *)e); }
visit(OverExp * e)633     virtual void visit(OverExp *e) { visit((Expression *)e); }
visit(HaltExp * e)634     virtual void visit(HaltExp *e) { visit((Expression *)e); }
visit(DotTemplateExp * e)635     virtual void visit(DotTemplateExp *e) { visit((UnaExp *)e); }
visit(DotVarExp * e)636     virtual void visit(DotVarExp *e) { visit((UnaExp *)e); }
visit(DelegateExp * e)637     virtual void visit(DelegateExp *e) { visit((UnaExp *)e); }
visit(DotTypeExp * e)638     virtual void visit(DotTypeExp *e) { visit((UnaExp *)e); }
visit(VectorExp * e)639     virtual void visit(VectorExp *e) { visit((UnaExp *)e); }
visit(VectorArrayExp * e)640     virtual void visit(VectorArrayExp *e) { visit((UnaExp *)e); }
visit(SliceExp * e)641     virtual void visit(SliceExp *e) { visit((UnaExp *)e); }
visit(ArrayLengthExp * e)642     virtual void visit(ArrayLengthExp *e) { visit((UnaExp *)e); }
visit(DelegatePtrExp * e)643     virtual void visit(DelegatePtrExp *e) { visit((UnaExp *)e); }
visit(DelegateFuncptrExp * e)644     virtual void visit(DelegateFuncptrExp *e) { visit((UnaExp *)e); }
visit(DotExp * e)645     virtual void visit(DotExp *e) { visit((BinExp *)e); }
visit(IndexExp * e)646     virtual void visit(IndexExp *e) { visit((BinExp *)e); }
visit(ConstructExp * e)647     virtual void visit(ConstructExp *e) { visit((AssignExp *)e); }
visit(BlitExp * e)648     virtual void visit(BlitExp *e) { visit((AssignExp *)e); }
visit(RemoveExp * e)649     virtual void visit(RemoveExp *e) { visit((BinExp *)e); }
visit(ClassReferenceExp * e)650     virtual void visit(ClassReferenceExp *e) { visit((Expression *)e); }
visit(VoidInitExp * e)651     virtual void visit(VoidInitExp *e) { visit((Expression *)e); }
visit(ThrownExceptionExp * e)652     virtual void visit(ThrownExceptionExp *e) { visit((Expression *)e); }
653 };
654 
655 class StoppableVisitor : public Visitor
656 {
657 public:
658     bool stop;
StoppableVisitor()659     StoppableVisitor() : stop(false) {}
660 };
661