xref: /netbsd-src/external/gpl3/gcc/dist/gcc/d/dmd/visitor.h (revision b1e838363e3c6fc78a55519254d99869742dd33c)
1 
2 /* Compiler implementation of the D programming language
3  * Copyright (C) 2013-2022 by The D Language Foundation, All Rights Reserved
4  * https://www.digitalmars.com
5  * Distributed under the Boost Software License, Version 1.0.
6  * https://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 ThrowExp;
224 class DotIdExp;
225 class DotTemplateExp;
226 class DotVarExp;
227 class DotTemplateInstanceExp;
228 class DelegateExp;
229 class DotTypeExp;
230 class CallExp;
231 class AddrExp;
232 class PtrExp;
233 class NegExp;
234 class UAddExp;
235 class ComExp;
236 class NotExp;
237 class DeleteExp;
238 class CastExp;
239 class VectorExp;
240 class VectorArrayExp;
241 class SliceExp;
242 class ArrayLengthExp;
243 class IntervalExp;
244 class DelegatePtrExp;
245 class DelegateFuncptrExp;
246 class ArrayExp;
247 class DotExp;
248 class CommaExp;
249 class IndexExp;
250 class PostExp;
251 class PreExp;
252 class AssignExp;
253 class ConstructExp;
254 class BlitExp;
255 class AddAssignExp;
256 class MinAssignExp;
257 class MulAssignExp;
258 class DivAssignExp;
259 class ModAssignExp;
260 class AndAssignExp;
261 class OrAssignExp;
262 class XorAssignExp;
263 class PowAssignExp;
264 class ShlAssignExp;
265 class ShrAssignExp;
266 class UshrAssignExp;
267 class CatAssignExp;
268 class AddExp;
269 class MinExp;
270 class CatExp;
271 class MulExp;
272 class DivExp;
273 class ModExp;
274 class PowExp;
275 class ShlExp;
276 class ShrExp;
277 class UshrExp;
278 class AndExp;
279 class OrExp;
280 class XorExp;
281 class LogicalExp;
282 class CmpExp;
283 class InExp;
284 class RemoveExp;
285 class EqualExp;
286 class IdentityExp;
287 class CondExp;
288 class DefaultInitExp;
289 class FileInitExp;
290 class LineInitExp;
291 class ModuleInitExp;
292 class FuncInitExp;
293 class PrettyFuncInitExp;
294 class ClassReferenceExp;
295 class VoidInitExp;
296 class ThrownExceptionExp;
297 class GenericExp;
298 
299 class TemplateParameter;
300 class TemplateTypeParameter;
301 class TemplateThisParameter;
302 class TemplateValueParameter;
303 class TemplateAliasParameter;
304 class TemplateTupleParameter;
305 
306 class Condition;
307 class DVCondition;
308 class DebugCondition;
309 class VersionCondition;
310 class StaticIfCondition;
311 
312 class Parameter;
313 
314 class ParseTimeVisitor
315 {
316 public:
visit(Dsymbol *)317     virtual void visit(Dsymbol *) { assert(0); }
visit(Parameter *)318     virtual void visit(Parameter *) { assert(0); }
visit(Statement *)319     virtual void visit(Statement *) { assert(0); }
visit(Type *)320     virtual void visit(Type *) { assert(0); }
visit(Expression *)321     virtual void visit(Expression *) { assert(0); }
visit(TemplateParameter *)322     virtual void visit(TemplateParameter *) { assert(0); }
visit(Condition *)323     virtual void visit(Condition *) { assert(0); }
visit(Initializer *)324     virtual void visit(Initializer *) { assert(0); }
325 
326     // Dsymbols
visit(AliasThis * s)327     virtual void visit(AliasThis *s) { visit((Dsymbol *)s); }
visit(Declaration * s)328     virtual void visit(Declaration *s) { visit((Dsymbol *)s); }
visit(ScopeDsymbol * s)329     virtual void visit(ScopeDsymbol *s) { visit((Dsymbol *)s); }
visit(Import * s)330     virtual void visit(Import *s) { visit((Dsymbol *)s); }
visit(AttribDeclaration * s)331     virtual void visit(AttribDeclaration *s) { visit((Dsymbol *)s); }
visit(StaticAssert * s)332     virtual void visit(StaticAssert *s) { visit((Dsymbol *)s); }
visit(DebugSymbol * s)333     virtual void visit(DebugSymbol *s) { visit((Dsymbol *)s); }
visit(VersionSymbol * s)334     virtual void visit(VersionSymbol *s) { visit((Dsymbol *)s); }
visit(AliasAssign * s)335     virtual void visit(AliasAssign *s) { visit((Dsymbol *)s); }
336 
337     // ScopeDsymbols
visit(Package * s)338     virtual void visit(Package *s) { visit((ScopeDsymbol *)s); }
visit(EnumDeclaration * s)339     virtual void visit(EnumDeclaration *s) { visit((ScopeDsymbol *)s); }
visit(AggregateDeclaration * s)340     virtual void visit(AggregateDeclaration *s) { visit((ScopeDsymbol *)s); }
visit(TemplateDeclaration * s)341     virtual void visit(TemplateDeclaration *s) { visit((ScopeDsymbol *)s); }
visit(TemplateInstance * s)342     virtual void visit(TemplateInstance *s) { visit((ScopeDsymbol *)s); }
visit(Nspace * s)343     virtual void visit(Nspace *s) { visit((ScopeDsymbol *)s); }
344 
345     // Declarations
visit(VarDeclaration * s)346     virtual void visit(VarDeclaration *s) { visit((Declaration *)s); }
visit(FuncDeclaration * s)347     virtual void visit(FuncDeclaration *s) { visit((Declaration *)s); }
visit(AliasDeclaration * s)348     virtual void visit(AliasDeclaration *s) { visit((Declaration *)s); }
visit(TupleDeclaration * s)349     virtual void visit(TupleDeclaration *s) { visit((Declaration *)s); }
350 
351     // FuncDeclarations
visit(FuncLiteralDeclaration * s)352     virtual void visit(FuncLiteralDeclaration *s) { visit((FuncDeclaration *)s); }
visit(PostBlitDeclaration * s)353     virtual void visit(PostBlitDeclaration *s) { visit((FuncDeclaration *)s); }
visit(CtorDeclaration * s)354     virtual void visit(CtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(DtorDeclaration * s)355     virtual void visit(DtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(InvariantDeclaration * s)356     virtual void visit(InvariantDeclaration *s) { visit((FuncDeclaration *)s); }
visit(UnitTestDeclaration * s)357     virtual void visit(UnitTestDeclaration *s) { visit((FuncDeclaration *)s); }
visit(NewDeclaration * s)358     virtual void visit(NewDeclaration *s) { visit((FuncDeclaration *)s); }
visit(StaticCtorDeclaration * s)359     virtual void visit(StaticCtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(StaticDtorDeclaration * s)360     virtual void visit(StaticDtorDeclaration *s) { visit((FuncDeclaration *)s); }
visit(SharedStaticCtorDeclaration * s)361     virtual void visit(SharedStaticCtorDeclaration *s) { visit((StaticCtorDeclaration *)s); }
visit(SharedStaticDtorDeclaration * s)362     virtual void visit(SharedStaticDtorDeclaration *s) { visit((StaticDtorDeclaration *)s); }
363 
364     // AttribDeclarations
visit(CompileDeclaration * s)365     virtual void visit(CompileDeclaration *s) { visit((AttribDeclaration *)s); }
visit(UserAttributeDeclaration * s)366     virtual void visit(UserAttributeDeclaration *s) { visit((AttribDeclaration *)s); }
visit(LinkDeclaration * s)367     virtual void visit(LinkDeclaration *s) { visit((AttribDeclaration *)s); }
visit(AnonDeclaration * s)368     virtual void visit(AnonDeclaration *s) { visit((AttribDeclaration *)s); }
visit(AlignDeclaration * s)369     virtual void visit(AlignDeclaration *s) { visit((AttribDeclaration *)s); }
visit(CPPMangleDeclaration * s)370     virtual void visit(CPPMangleDeclaration *s) { visit((AttribDeclaration *)s); }
visit(CPPNamespaceDeclaration * s)371     virtual void visit(CPPNamespaceDeclaration *s) { visit((AttribDeclaration *)s); }
visit(VisibilityDeclaration * s)372     virtual void visit(VisibilityDeclaration *s) { visit((AttribDeclaration *)s); }
visit(PragmaDeclaration * s)373     virtual void visit(PragmaDeclaration *s) { visit((AttribDeclaration *)s); }
visit(StorageClassDeclaration * s)374     virtual void visit(StorageClassDeclaration *s) { visit((AttribDeclaration *)s); }
visit(ConditionalDeclaration * s)375     virtual void visit(ConditionalDeclaration *s) { visit((AttribDeclaration *)s); }
visit(StaticForeachDeclaration * s)376     virtual void visit(StaticForeachDeclaration *s) { visit((AttribDeclaration *)s); }
377 
378     // Miscellaneous
visit(DeprecatedDeclaration * s)379     virtual void visit(DeprecatedDeclaration *s) { visit((StorageClassDeclaration *)s); }
visit(StaticIfDeclaration * s)380     virtual void visit(StaticIfDeclaration *s) { visit((ConditionalDeclaration *)s); }
visit(EnumMember * s)381     virtual void visit(EnumMember *s) { visit((VarDeclaration *)s); }
visit(Module * s)382     virtual void visit(Module *s) { visit((Package *)s); }
visit(StructDeclaration * s)383     virtual void visit(StructDeclaration *s) { visit((AggregateDeclaration *)s); }
visit(UnionDeclaration * s)384     virtual void visit(UnionDeclaration *s) { visit((StructDeclaration *)s); }
visit(ClassDeclaration * s)385     virtual void visit(ClassDeclaration *s) { visit((AggregateDeclaration *)s); }
visit(InterfaceDeclaration * s)386     virtual void visit(InterfaceDeclaration *s) { visit((ClassDeclaration *)s); }
visit(TemplateMixin * s)387     virtual void visit(TemplateMixin *s) { visit((TemplateInstance *)s); }
visit(BitFieldDeclaration * s)388     virtual void visit(BitFieldDeclaration *s) { visit((VarDeclaration *)s); }
389 
390     // Statements
visit(ImportStatement * s)391     virtual void visit(ImportStatement *s) { visit((Statement *)s); }
visit(ScopeStatement * s)392     virtual void visit(ScopeStatement *s) { visit((Statement *)s); }
visit(ReturnStatement * s)393     virtual void visit(ReturnStatement *s) { visit((Statement *)s); }
visit(LabelStatement * s)394     virtual void visit(LabelStatement *s) { visit((Statement *)s); }
visit(StaticAssertStatement * s)395     virtual void visit(StaticAssertStatement *s) { visit((Statement *)s); }
visit(CompileStatement * s)396     virtual void visit(CompileStatement *s) { visit((Statement *)s); }
visit(WhileStatement * s)397     virtual void visit(WhileStatement *s) { visit((Statement *)s); }
visit(ForStatement * s)398     virtual void visit(ForStatement *s) { visit((Statement *)s); }
visit(DoStatement * s)399     virtual void visit(DoStatement *s) { visit((Statement *)s); }
visit(ForeachRangeStatement * s)400     virtual void visit(ForeachRangeStatement *s) { visit((Statement *)s); }
visit(ForeachStatement * s)401     virtual void visit(ForeachStatement *s) { visit((Statement *)s); }
visit(IfStatement * s)402     virtual void visit(IfStatement *s) { visit((Statement *)s); }
visit(ScopeGuardStatement * s)403     virtual void visit(ScopeGuardStatement *s) { visit((Statement *)s); }
visit(ConditionalStatement * s)404     virtual void visit(ConditionalStatement *s) { visit((Statement *)s); }
visit(StaticForeachStatement * s)405     virtual void visit(StaticForeachStatement *s) { visit((Statement *)s); }
visit(PragmaStatement * s)406     virtual void visit(PragmaStatement *s) { visit((Statement *)s); }
visit(SwitchStatement * s)407     virtual void visit(SwitchStatement *s) { visit((Statement *)s); }
visit(CaseRangeStatement * s)408     virtual void visit(CaseRangeStatement *s) { visit((Statement *)s); }
visit(CaseStatement * s)409     virtual void visit(CaseStatement *s) { visit((Statement *)s); }
visit(DefaultStatement * s)410     virtual void visit(DefaultStatement *s) { visit((Statement *)s); }
visit(BreakStatement * s)411     virtual void visit(BreakStatement *s) { visit((Statement *)s); }
visit(ContinueStatement * s)412     virtual void visit(ContinueStatement *s) { visit((Statement *)s); }
visit(GotoDefaultStatement * s)413     virtual void visit(GotoDefaultStatement *s) { visit((Statement *)s); }
visit(GotoCaseStatement * s)414     virtual void visit(GotoCaseStatement *s) { visit((Statement *)s); }
visit(GotoStatement * s)415     virtual void visit(GotoStatement *s) { visit((Statement *)s); }
visit(SynchronizedStatement * s)416     virtual void visit(SynchronizedStatement *s) { visit((Statement *)s); }
visit(WithStatement * s)417     virtual void visit(WithStatement *s) { visit((Statement *)s); }
visit(TryCatchStatement * s)418     virtual void visit(TryCatchStatement *s) { visit((Statement *)s); }
visit(TryFinallyStatement * s)419     virtual void visit(TryFinallyStatement *s) { visit((Statement *)s); }
visit(ThrowStatement * s)420     virtual void visit(ThrowStatement *s) { visit((Statement *)s); }
visit(AsmStatement * s)421     virtual void visit(AsmStatement *s) { visit((Statement *)s); }
visit(ExpStatement * s)422     virtual void visit(ExpStatement *s) { visit((Statement *)s); }
visit(CompoundStatement * s)423     virtual void visit(CompoundStatement *s) { visit((Statement *)s); }
424 
425     // CompoundStatements
visit(CompoundDeclarationStatement * s)426     virtual void visit(CompoundDeclarationStatement *s) { visit((CompoundStatement *)s); }
visit(CompoundAsmStatement * s)427     virtual void visit(CompoundAsmStatement *s) { visit((CompoundStatement *)s); }
428 
429     // AsmStatements
visit(InlineAsmStatement * s)430     virtual void visit(InlineAsmStatement *s) { visit((AsmStatement *)s); }
visit(GccAsmStatement * s)431     virtual void visit(GccAsmStatement *s) { visit((AsmStatement *)s); }
432 
433     // Types
visit(TypeBasic * t)434     virtual void visit(TypeBasic *t) { visit((Type *)t); }
visit(TypeError * t)435     virtual void visit(TypeError *t) { visit((Type *)t); }
visit(TypeNull * t)436     virtual void visit(TypeNull *t) { visit((Type *)t); }
visit(TypeNoreturn * t)437     virtual void visit(TypeNoreturn *t) { visit((Type *)t); }
visit(TypeVector * t)438     virtual void visit(TypeVector *t) { visit((Type *)t); }
visit(TypeEnum * t)439     virtual void visit(TypeEnum *t) { visit((Type *)t); }
visit(TypeTuple * t)440     virtual void visit(TypeTuple *t) { visit((Type *)t); }
visit(TypeClass * t)441     virtual void visit(TypeClass *t) { visit((Type *)t); }
visit(TypeStruct * t)442     virtual void visit(TypeStruct *t) { visit((Type *)t); }
visit(TypeNext * t)443     virtual void visit(TypeNext *t) { visit((Type *)t); }
visit(TypeQualified * t)444     virtual void visit(TypeQualified *t) { visit((Type *)t); }
visit(TypeTraits * t)445     virtual void visit(TypeTraits *t) { visit((Type *)t); }
visit(TypeMixin * t)446     virtual void visit(TypeMixin *t) { visit((Type *)t); }
visit(TypeTag * t)447     virtual void visit(TypeTag *t) { visit((Type *)t); }
448 
449     // TypeNext
visit(TypeReference * t)450     virtual void visit(TypeReference *t) { visit((TypeNext *)t); }
visit(TypeSlice * t)451     virtual void visit(TypeSlice *t) { visit((TypeNext *)t); }
visit(TypeDelegate * t)452     virtual void visit(TypeDelegate *t) { visit((TypeNext *)t); }
visit(TypePointer * t)453     virtual void visit(TypePointer *t) { visit((TypeNext *)t); }
visit(TypeFunction * t)454     virtual void visit(TypeFunction *t) { visit((TypeNext *)t); }
visit(TypeArray * t)455     virtual void visit(TypeArray *t) { visit((TypeNext *)t); }
456 
457     // TypeArray
visit(TypeDArray * t)458     virtual void visit(TypeDArray *t) { visit((TypeArray *)t); }
visit(TypeAArray * t)459     virtual void visit(TypeAArray *t) { visit((TypeArray *)t); }
visit(TypeSArray * t)460     virtual void visit(TypeSArray *t) { visit((TypeArray *)t); }
461 
462     // TypeQualified
visit(TypeIdentifier * t)463     virtual void visit(TypeIdentifier *t) { visit((TypeQualified *)t); }
visit(TypeReturn * t)464     virtual void visit(TypeReturn *t) { visit((TypeQualified *)t); }
visit(TypeTypeof * t)465     virtual void visit(TypeTypeof *t) { visit((TypeQualified *)t); }
visit(TypeInstance * t)466     virtual void visit(TypeInstance *t) { visit((TypeQualified *)t); }
467 
468     // Expressions
visit(DeclarationExp * e)469     virtual void visit(DeclarationExp *e) { visit((Expression *)e); }
visit(IntegerExp * e)470     virtual void visit(IntegerExp *e) { visit((Expression *)e); }
visit(NewAnonClassExp * e)471     virtual void visit(NewAnonClassExp *e) { visit((Expression *)e); }
visit(IsExp * e)472     virtual void visit(IsExp *e) { visit((Expression *)e); }
visit(RealExp * e)473     virtual void visit(RealExp *e) { visit((Expression *)e); }
visit(NullExp * e)474     virtual void visit(NullExp *e) { visit((Expression *)e); }
visit(TypeidExp * e)475     virtual void visit(TypeidExp *e) { visit((Expression *)e); }
visit(TraitsExp * e)476     virtual void visit(TraitsExp *e) { visit((Expression *)e); }
visit(StringExp * e)477     virtual void visit(StringExp *e) { visit((Expression *)e); }
visit(NewExp * e)478     virtual void visit(NewExp *e) { visit((Expression *)e); }
visit(AssocArrayLiteralExp * e)479     virtual void visit(AssocArrayLiteralExp *e) { visit((Expression *)e); }
visit(ArrayLiteralExp * e)480     virtual void visit(ArrayLiteralExp *e) { visit((Expression *)e); }
visit(MixinExp * e)481     virtual void visit(MixinExp *e) { visit((Expression *)e); }
visit(FuncExp * e)482     virtual void visit(FuncExp *e) { visit((Expression *)e); }
visit(IntervalExp * e)483     virtual void visit(IntervalExp *e) { visit((Expression *)e); }
visit(TypeExp * e)484     virtual void visit(TypeExp *e) { visit((Expression *)e); }
visit(ScopeExp * e)485     virtual void visit(ScopeExp *e) { visit((Expression *)e); }
visit(IdentifierExp * e)486     virtual void visit(IdentifierExp *e) { visit((Expression *)e); }
visit(UnaExp * e)487     virtual void visit(UnaExp *e) { visit((Expression *)e); }
visit(DefaultInitExp * e)488     virtual void visit(DefaultInitExp *e) { visit((Expression *)e); }
visit(BinExp * e)489     virtual void visit(BinExp *e) { visit((Expression *)e); }
visit(DsymbolExp * e)490     virtual void visit(DsymbolExp *e) { visit((Expression *)e); }
visit(TemplateExp * e)491     virtual void visit(TemplateExp *e) { visit((Expression *)e); }
visit(SymbolExp * e)492     virtual void visit(SymbolExp *e) { visit((Expression *)e); }
visit(TupleExp * e)493     virtual void visit(TupleExp *e) { visit((Expression *)e); }
visit(ThisExp * e)494     virtual void visit(ThisExp *e) { visit((Expression *)e); }
visit(GenericExp * e)495     virtual void visit(GenericExp *e) { visit((Expression *)e); }
496 
497     // Miscellaneous
visit(VarExp * e)498     virtual void visit(VarExp *e) { visit((SymbolExp *)e); }
visit(DollarExp * e)499     virtual void visit(DollarExp *e) { visit((IdentifierExp *)e); }
visit(SuperExp * e)500     virtual void visit(SuperExp *e) { visit((ThisExp *)e); }
501 
502     // UnaExp
visit(AddrExp * e)503     virtual void visit(AddrExp *e) { visit((UnaExp *)e); }
visit(PreExp * e)504     virtual void visit(PreExp *e) { visit((UnaExp *)e); }
visit(PtrExp * e)505     virtual void visit(PtrExp *e) { visit((UnaExp *)e); }
visit(NegExp * e)506     virtual void visit(NegExp *e) { visit((UnaExp *)e); }
visit(UAddExp * e)507     virtual void visit(UAddExp *e) { visit((UnaExp *)e); }
visit(NotExp * e)508     virtual void visit(NotExp *e) { visit((UnaExp *)e); }
visit(ComExp * e)509     virtual void visit(ComExp *e) { visit((UnaExp *)e); }
visit(DeleteExp * e)510     virtual void visit(DeleteExp *e) { visit((UnaExp *)e); }
visit(CastExp * e)511     virtual void visit(CastExp *e) { visit((UnaExp *)e); }
visit(CallExp * e)512     virtual void visit(CallExp *e) { visit((UnaExp *)e); }
visit(DotIdExp * e)513     virtual void visit(DotIdExp *e) { visit((UnaExp *)e); }
visit(AssertExp * e)514     virtual void visit(AssertExp *e) { visit((UnaExp *)e); }
visit(ThrowExp * e)515     virtual void visit(ThrowExp *e) { visit((UnaExp *)e); }
visit(ImportExp * e)516     virtual void visit(ImportExp *e) { visit((UnaExp *)e); }
visit(DotTemplateInstanceExp * e)517     virtual void visit(DotTemplateInstanceExp *e) { visit((UnaExp *)e); }
visit(ArrayExp * e)518     virtual void visit(ArrayExp *e) { visit((UnaExp *)e); }
519 
520     // DefaultInitExp
visit(FuncInitExp * e)521     virtual void visit(FuncInitExp *e) { visit((DefaultInitExp *)e); }
visit(PrettyFuncInitExp * e)522     virtual void visit(PrettyFuncInitExp *e) { visit((DefaultInitExp *)e); }
visit(FileInitExp * e)523     virtual void visit(FileInitExp *e) { visit((DefaultInitExp *)e); }
visit(LineInitExp * e)524     virtual void visit(LineInitExp *e) { visit((DefaultInitExp *)e); }
visit(ModuleInitExp * e)525     virtual void visit(ModuleInitExp *e) { visit((DefaultInitExp *)e); }
526 
527     // BinExp
visit(CommaExp * e)528     virtual void visit(CommaExp *e) { visit((BinExp *)e); }
visit(PostExp * e)529     virtual void visit(PostExp *e) { visit((BinExp *)e); }
visit(PowExp * e)530     virtual void visit(PowExp *e) { visit((BinExp *)e); }
visit(MulExp * e)531     virtual void visit(MulExp *e) { visit((BinExp *)e); }
visit(DivExp * e)532     virtual void visit(DivExp *e) { visit((BinExp *)e); }
visit(ModExp * e)533     virtual void visit(ModExp *e) { visit((BinExp *)e); }
visit(AddExp * e)534     virtual void visit(AddExp *e) { visit((BinExp *)e); }
visit(MinExp * e)535     virtual void visit(MinExp *e) { visit((BinExp *)e); }
visit(CatExp * e)536     virtual void visit(CatExp *e) { visit((BinExp *)e); }
visit(ShlExp * e)537     virtual void visit(ShlExp *e) { visit((BinExp *)e); }
visit(ShrExp * e)538     virtual void visit(ShrExp *e) { visit((BinExp *)e); }
visit(UshrExp * e)539     virtual void visit(UshrExp *e) { visit((BinExp *)e); }
visit(EqualExp * e)540     virtual void visit(EqualExp *e) { visit((BinExp *)e); }
visit(InExp * e)541     virtual void visit(InExp *e) { visit((BinExp *)e); }
visit(IdentityExp * e)542     virtual void visit(IdentityExp *e) { visit((BinExp *)e); }
visit(CmpExp * e)543     virtual void visit(CmpExp *e) { visit((BinExp *)e); }
visit(AndExp * e)544     virtual void visit(AndExp *e) { visit((BinExp *)e); }
visit(XorExp * e)545     virtual void visit(XorExp *e) { visit((BinExp *)e); }
visit(OrExp * e)546     virtual void visit(OrExp *e) { visit((BinExp *)e); }
visit(LogicalExp * e)547     virtual void visit(LogicalExp *e) { visit((BinExp *)e); }
visit(CondExp * e)548     virtual void visit(CondExp *e) { visit((BinExp *)e); }
visit(AssignExp * e)549     virtual void visit(AssignExp *e) { visit((BinExp *)e); }
visit(BinAssignExp * e)550     virtual void visit(BinAssignExp *e) { visit((BinExp *)e); }
551 
552     // BinAssignExp
visit(AddAssignExp * e)553     virtual void visit(AddAssignExp *e) { visit((BinAssignExp *)e); }
visit(MinAssignExp * e)554     virtual void visit(MinAssignExp *e) { visit((BinAssignExp *)e); }
visit(MulAssignExp * e)555     virtual void visit(MulAssignExp *e) { visit((BinAssignExp *)e); }
visit(DivAssignExp * e)556     virtual void visit(DivAssignExp *e) { visit((BinAssignExp *)e); }
visit(ModAssignExp * e)557     virtual void visit(ModAssignExp *e) { visit((BinAssignExp *)e); }
visit(PowAssignExp * e)558     virtual void visit(PowAssignExp *e) { visit((BinAssignExp *)e); }
visit(AndAssignExp * e)559     virtual void visit(AndAssignExp *e) { visit((BinAssignExp *)e); }
visit(OrAssignExp * e)560     virtual void visit(OrAssignExp *e) { visit((BinAssignExp *)e); }
visit(XorAssignExp * e)561     virtual void visit(XorAssignExp *e) { visit((BinAssignExp *)e); }
visit(ShlAssignExp * e)562     virtual void visit(ShlAssignExp *e) { visit((BinAssignExp *)e); }
visit(ShrAssignExp * e)563     virtual void visit(ShrAssignExp *e) { visit((BinAssignExp *)e); }
visit(UshrAssignExp * e)564     virtual void visit(UshrAssignExp *e) { visit((BinAssignExp *)e); }
visit(CatAssignExp * e)565     virtual void visit(CatAssignExp *e) { visit((BinAssignExp *)e); }
566 
567     // TemplateParameter
visit(TemplateAliasParameter * tp)568     virtual void visit(TemplateAliasParameter *tp) { visit((TemplateParameter *)tp); }
visit(TemplateTypeParameter * tp)569     virtual void visit(TemplateTypeParameter *tp) { visit((TemplateParameter *)tp); }
visit(TemplateTupleParameter * tp)570     virtual void visit(TemplateTupleParameter *tp) { visit((TemplateParameter *)tp); }
visit(TemplateValueParameter * tp)571     virtual void visit(TemplateValueParameter *tp) { visit((TemplateParameter *)tp); }
572 
visit(TemplateThisParameter * tp)573     virtual void visit(TemplateThisParameter *tp) { visit((TemplateTypeParameter *)tp); }
574 
575     // Condition
visit(StaticIfCondition * c)576     virtual void visit(StaticIfCondition *c) { visit((Condition *)c); }
visit(DVCondition * c)577     virtual void visit(DVCondition *c) { visit((Condition *)c); }
visit(DebugCondition * c)578     virtual void visit(DebugCondition *c) { visit((DVCondition *)c); }
visit(VersionCondition * c)579     virtual void visit(VersionCondition *c) { visit((DVCondition *)c); }
580 
581     // Initializer
visit(ExpInitializer * i)582     virtual void visit(ExpInitializer *i) { visit((Initializer *)i); }
visit(StructInitializer * i)583     virtual void visit(StructInitializer *i) { visit((Initializer *)i); }
visit(ArrayInitializer * i)584     virtual void visit(ArrayInitializer *i) { visit((Initializer *)i); }
visit(VoidInitializer * i)585     virtual void visit(VoidInitializer *i) { visit((Initializer *)i); }
visit(CInitializer * i)586     virtual void visit(CInitializer *i) { visit((Initializer *)i); }
587 };
588 
589 class Visitor : public ParseTimeVisitor
590 {
591 public:
592     using ParseTimeVisitor::visit;
593 
594     // Miscellaneous
visit(ErrorStatement * s)595     virtual void visit(ErrorStatement *s) { visit((Statement *)s); }
visit(PeelStatement * s)596     virtual void visit(PeelStatement *s) { visit((Statement *)s); }
visit(UnrolledLoopStatement * s)597     virtual void visit(UnrolledLoopStatement *s) { visit((Statement *)s); }
visit(SwitchErrorStatement * s)598     virtual void visit(SwitchErrorStatement *s) { visit((Statement *)s); }
visit(DebugStatement * s)599     virtual void visit(DebugStatement *s) { visit((Statement *)s); }
visit(DtorExpStatement * s)600     virtual void visit(DtorExpStatement *s) { visit((ExpStatement *)s); }
visit(ForwardingStatement * s)601     virtual void visit(ForwardingStatement *s) { visit((Statement *)s); }
visit(OverloadSet * s)602     virtual void visit(OverloadSet *s) { visit((Dsymbol *)s); }
visit(LabelDsymbol * s)603     virtual void visit(LabelDsymbol *s) { visit((Dsymbol *)s); }
visit(WithScopeSymbol * s)604     virtual void visit(WithScopeSymbol *s) { visit((ScopeDsymbol *)s); }
visit(ArrayScopeSymbol * s)605     virtual void visit(ArrayScopeSymbol *s) { visit((ScopeDsymbol *)s); }
visit(OverDeclaration * s)606     virtual void visit(OverDeclaration *s) { visit((Declaration *)s); }
visit(SymbolDeclaration * s)607     virtual void visit(SymbolDeclaration *s) { visit((Declaration *)s); }
visit(ForwardingAttribDeclaration * s)608     virtual void visit(ForwardingAttribDeclaration *s) { visit((AttribDeclaration *)s); }
visit(ThisDeclaration * s)609     virtual void visit(ThisDeclaration *s) { visit((VarDeclaration *)s); }
visit(TypeInfoDeclaration * s)610     virtual void visit(TypeInfoDeclaration *s) { visit((VarDeclaration *)s); }
visit(TypeInfoStructDeclaration * s)611     virtual void visit(TypeInfoStructDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoClassDeclaration * s)612     virtual void visit(TypeInfoClassDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoInterfaceDeclaration * s)613     virtual void visit(TypeInfoInterfaceDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoPointerDeclaration * s)614     virtual void visit(TypeInfoPointerDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoArrayDeclaration * s)615     virtual void visit(TypeInfoArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoStaticArrayDeclaration * s)616     virtual void visit(TypeInfoStaticArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoAssociativeArrayDeclaration * s)617     virtual void visit(TypeInfoAssociativeArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoEnumDeclaration * s)618     virtual void visit(TypeInfoEnumDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoFunctionDeclaration * s)619     virtual void visit(TypeInfoFunctionDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoDelegateDeclaration * s)620     virtual void visit(TypeInfoDelegateDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoTupleDeclaration * s)621     virtual void visit(TypeInfoTupleDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoConstDeclaration * s)622     virtual void visit(TypeInfoConstDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoInvariantDeclaration * s)623     virtual void visit(TypeInfoInvariantDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoSharedDeclaration * s)624     virtual void visit(TypeInfoSharedDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoWildDeclaration * s)625     virtual void visit(TypeInfoWildDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(TypeInfoVectorDeclaration * s)626     virtual void visit(TypeInfoVectorDeclaration *s) { visit((TypeInfoDeclaration *)s); }
visit(FuncAliasDeclaration * s)627     virtual void visit(FuncAliasDeclaration *s) { visit((FuncDeclaration *)s); }
visit(ErrorInitializer * i)628     virtual void visit(ErrorInitializer *i) { visit((Initializer *)i); }
visit(ErrorExp * e)629     virtual void visit(ErrorExp *e) { visit((Expression *)e); }
visit(ComplexExp * e)630     virtual void visit(ComplexExp *e) { visit((Expression *)e); }
visit(StructLiteralExp * e)631     virtual void visit(StructLiteralExp *e) { visit((Expression *)e); }
visit(CompoundLiteralExp * e)632     virtual void visit(CompoundLiteralExp *e) { visit((Expression *)e); }
visit(ObjcClassReferenceExp * e)633     virtual void visit(ObjcClassReferenceExp *e) { visit((Expression *)e); }
visit(SymOffExp * e)634     virtual void visit(SymOffExp *e) { visit((SymbolExp *)e); }
visit(OverExp * e)635     virtual void visit(OverExp *e) { visit((Expression *)e); }
visit(HaltExp * e)636     virtual void visit(HaltExp *e) { visit((Expression *)e); }
visit(DotTemplateExp * e)637     virtual void visit(DotTemplateExp *e) { visit((UnaExp *)e); }
visit(DotVarExp * e)638     virtual void visit(DotVarExp *e) { visit((UnaExp *)e); }
visit(DelegateExp * e)639     virtual void visit(DelegateExp *e) { visit((UnaExp *)e); }
visit(DotTypeExp * e)640     virtual void visit(DotTypeExp *e) { visit((UnaExp *)e); }
visit(VectorExp * e)641     virtual void visit(VectorExp *e) { visit((UnaExp *)e); }
visit(VectorArrayExp * e)642     virtual void visit(VectorArrayExp *e) { visit((UnaExp *)e); }
visit(SliceExp * e)643     virtual void visit(SliceExp *e) { visit((UnaExp *)e); }
visit(ArrayLengthExp * e)644     virtual void visit(ArrayLengthExp *e) { visit((UnaExp *)e); }
visit(DelegatePtrExp * e)645     virtual void visit(DelegatePtrExp *e) { visit((UnaExp *)e); }
visit(DelegateFuncptrExp * e)646     virtual void visit(DelegateFuncptrExp *e) { visit((UnaExp *)e); }
visit(DotExp * e)647     virtual void visit(DotExp *e) { visit((BinExp *)e); }
visit(IndexExp * e)648     virtual void visit(IndexExp *e) { visit((BinExp *)e); }
visit(ConstructExp * e)649     virtual void visit(ConstructExp *e) { visit((AssignExp *)e); }
visit(BlitExp * e)650     virtual void visit(BlitExp *e) { visit((AssignExp *)e); }
visit(RemoveExp * e)651     virtual void visit(RemoveExp *e) { visit((BinExp *)e); }
visit(ClassReferenceExp * e)652     virtual void visit(ClassReferenceExp *e) { visit((Expression *)e); }
visit(VoidInitExp * e)653     virtual void visit(VoidInitExp *e) { visit((Expression *)e); }
visit(ThrownExceptionExp * e)654     virtual void visit(ThrownExceptionExp *e) { visit((Expression *)e); }
655 };
656 
657 class StoppableVisitor : public Visitor
658 {
659 public:
660     bool stop;
StoppableVisitor()661     StoppableVisitor() : stop(false) {}
662 };
663