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 88 class Dsymbol; 89 90 class StaticAssert; 91 class DebugSymbol; 92 class VersionSymbol; 93 class EnumMember; 94 class Import; 95 class OverloadSet; 96 class LabelDsymbol; 97 class AliasThis; 98 99 class AttribDeclaration; 100 class StorageClassDeclaration; 101 class DeprecatedDeclaration; 102 class LinkDeclaration; 103 class CPPMangleDeclaration; 104 class ProtDeclaration; 105 class AlignDeclaration; 106 class AnonDeclaration; 107 class PragmaDeclaration; 108 class ConditionalDeclaration; 109 class StaticIfDeclaration; 110 class CompileDeclaration; 111 class StaticForeachDeclaration; 112 class UserAttributeDeclaration; 113 class ForwardingAttribDeclaration; 114 115 class ScopeDsymbol; 116 class TemplateDeclaration; 117 class TemplateInstance; 118 class TemplateMixin; 119 class EnumDeclaration; 120 class Package; 121 class Module; 122 class WithScopeSymbol; 123 class ArrayScopeSymbol; 124 class Nspace; 125 126 class AggregateDeclaration; 127 class StructDeclaration; 128 class UnionDeclaration; 129 class ClassDeclaration; 130 class InterfaceDeclaration; 131 132 class Declaration; 133 class TupleDeclaration; 134 class AliasDeclaration; 135 class OverDeclaration; 136 class VarDeclaration; 137 class SymbolDeclaration; 138 class ThisDeclaration; 139 140 class TypeInfoDeclaration; 141 class TypeInfoStructDeclaration; 142 class TypeInfoClassDeclaration; 143 class TypeInfoInterfaceDeclaration; 144 class TypeInfoPointerDeclaration; 145 class TypeInfoArrayDeclaration; 146 class TypeInfoStaticArrayDeclaration; 147 class TypeInfoAssociativeArrayDeclaration; 148 class TypeInfoEnumDeclaration; 149 class TypeInfoFunctionDeclaration; 150 class TypeInfoDelegateDeclaration; 151 class TypeInfoTupleDeclaration; 152 class TypeInfoConstDeclaration; 153 class TypeInfoInvariantDeclaration; 154 class TypeInfoSharedDeclaration; 155 class TypeInfoWildDeclaration; 156 class TypeInfoVectorDeclaration; 157 158 class FuncDeclaration; 159 class FuncAliasDeclaration; 160 class FuncLiteralDeclaration; 161 class CtorDeclaration; 162 class PostBlitDeclaration; 163 class DtorDeclaration; 164 class StaticCtorDeclaration; 165 class SharedStaticCtorDeclaration; 166 class StaticDtorDeclaration; 167 class SharedStaticDtorDeclaration; 168 class InvariantDeclaration; 169 class UnitTestDeclaration; 170 class NewDeclaration; 171 class DeleteDeclaration; 172 173 class Initializer; 174 class VoidInitializer; 175 class ErrorInitializer; 176 class StructInitializer; 177 class ArrayInitializer; 178 class ExpInitializer; 179 180 class Expression; 181 class IntegerExp; 182 class ErrorExp; 183 class RealExp; 184 class ComplexExp; 185 class IdentifierExp; 186 class DollarExp; 187 class DsymbolExp; 188 class ThisExp; 189 class SuperExp; 190 class NullExp; 191 class StringExp; 192 class TupleExp; 193 class ArrayLiteralExp; 194 class AssocArrayLiteralExp; 195 class StructLiteralExp; 196 class TypeExp; 197 class ScopeExp; 198 class TemplateExp; 199 class NewExp; 200 class NewAnonClassExp; 201 class SymbolExp; 202 class SymOffExp; 203 class VarExp; 204 class OverExp; 205 class FuncExp; 206 class DeclarationExp; 207 class TypeidExp; 208 class TraitsExp; 209 class HaltExp; 210 class IsExp; 211 class UnaExp; 212 class BinExp; 213 class BinAssignExp; 214 class CompileExp; 215 class ImportExp; 216 class AssertExp; 217 class DotIdExp; 218 class DotTemplateExp; 219 class DotVarExp; 220 class DotTemplateInstanceExp; 221 class DelegateExp; 222 class DotTypeExp; 223 class CallExp; 224 class AddrExp; 225 class PtrExp; 226 class NegExp; 227 class UAddExp; 228 class ComExp; 229 class NotExp; 230 class DeleteExp; 231 class CastExp; 232 class VectorExp; 233 class VectorArrayExp; 234 class SliceExp; 235 class ArrayLengthExp; 236 class IntervalExp; 237 class DelegatePtrExp; 238 class DelegateFuncptrExp; 239 class ArrayExp; 240 class DotExp; 241 class CommaExp; 242 class IndexExp; 243 class PostExp; 244 class PreExp; 245 class AssignExp; 246 class ConstructExp; 247 class BlitExp; 248 class AddAssignExp; 249 class MinAssignExp; 250 class MulAssignExp; 251 class DivAssignExp; 252 class ModAssignExp; 253 class AndAssignExp; 254 class OrAssignExp; 255 class XorAssignExp; 256 class PowAssignExp; 257 class ShlAssignExp; 258 class ShrAssignExp; 259 class UshrAssignExp; 260 class CatAssignExp; 261 class AddExp; 262 class MinExp; 263 class CatExp; 264 class MulExp; 265 class DivExp; 266 class ModExp; 267 class PowExp; 268 class ShlExp; 269 class ShrExp; 270 class UshrExp; 271 class AndExp; 272 class OrExp; 273 class XorExp; 274 class LogicalExp; 275 class CmpExp; 276 class InExp; 277 class RemoveExp; 278 class EqualExp; 279 class IdentityExp; 280 class CondExp; 281 class DefaultInitExp; 282 class FileInitExp; 283 class LineInitExp; 284 class ModuleInitExp; 285 class FuncInitExp; 286 class PrettyFuncInitExp; 287 class ClassReferenceExp; 288 class VoidInitExp; 289 class ThrownExceptionExp; 290 291 class TemplateParameter; 292 class TemplateTypeParameter; 293 class TemplateThisParameter; 294 class TemplateValueParameter; 295 class TemplateAliasParameter; 296 class TemplateTupleParameter; 297 298 class Condition; 299 class DVCondition; 300 class DebugCondition; 301 class VersionCondition; 302 class StaticIfCondition; 303 304 class Parameter; 305 306 class Visitor 307 { 308 public: visit(Statement *)309 virtual void visit(Statement *) { assert(0); } visit(ErrorStatement * s)310 virtual void visit(ErrorStatement *s) { visit((Statement *)s); } visit(PeelStatement * s)311 virtual void visit(PeelStatement *s) { visit((Statement *)s); } visit(ExpStatement * s)312 virtual void visit(ExpStatement *s) { visit((Statement *)s); } visit(DtorExpStatement * s)313 virtual void visit(DtorExpStatement *s) { visit((ExpStatement *)s); } visit(CompileStatement * s)314 virtual void visit(CompileStatement *s) { visit((Statement *)s); } visit(CompoundStatement * s)315 virtual void visit(CompoundStatement *s) { visit((Statement *)s); } visit(CompoundDeclarationStatement * s)316 virtual void visit(CompoundDeclarationStatement *s) { visit((CompoundStatement *)s); } visit(UnrolledLoopStatement * s)317 virtual void visit(UnrolledLoopStatement *s) { visit((Statement *)s); } visit(ScopeStatement * s)318 virtual void visit(ScopeStatement *s) { visit((Statement *)s); } visit(ForwardingStatement * s)319 virtual void visit(ForwardingStatement *s) { visit((Statement *)s); } visit(WhileStatement * s)320 virtual void visit(WhileStatement *s) { visit((Statement *)s); } visit(DoStatement * s)321 virtual void visit(DoStatement *s) { visit((Statement *)s); } visit(ForStatement * s)322 virtual void visit(ForStatement *s) { visit((Statement *)s); } visit(ForeachStatement * s)323 virtual void visit(ForeachStatement *s) { visit((Statement *)s); } visit(ForeachRangeStatement * s)324 virtual void visit(ForeachRangeStatement *s) { visit((Statement *)s); } visit(StaticForeachStatement * s)325 virtual void visit(StaticForeachStatement *s) { visit((Statement *)s); } visit(IfStatement * s)326 virtual void visit(IfStatement *s) { visit((Statement *)s); } visit(ConditionalStatement * s)327 virtual void visit(ConditionalStatement *s) { visit((Statement *)s); } visit(PragmaStatement * s)328 virtual void visit(PragmaStatement *s) { visit((Statement *)s); } visit(StaticAssertStatement * s)329 virtual void visit(StaticAssertStatement *s) { visit((Statement *)s); } visit(SwitchStatement * s)330 virtual void visit(SwitchStatement *s) { visit((Statement *)s); } visit(CaseStatement * s)331 virtual void visit(CaseStatement *s) { visit((Statement *)s); } visit(CaseRangeStatement * s)332 virtual void visit(CaseRangeStatement *s) { visit((Statement *)s); } visit(DefaultStatement * s)333 virtual void visit(DefaultStatement *s) { visit((Statement *)s); } visit(GotoDefaultStatement * s)334 virtual void visit(GotoDefaultStatement *s) { visit((Statement *)s); } visit(GotoCaseStatement * s)335 virtual void visit(GotoCaseStatement *s) { visit((Statement *)s); } visit(SwitchErrorStatement * s)336 virtual void visit(SwitchErrorStatement *s) { visit((Statement *)s); } visit(ReturnStatement * s)337 virtual void visit(ReturnStatement *s) { visit((Statement *)s); } visit(BreakStatement * s)338 virtual void visit(BreakStatement *s) { visit((Statement *)s); } visit(ContinueStatement * s)339 virtual void visit(ContinueStatement *s) { visit((Statement *)s); } visit(SynchronizedStatement * s)340 virtual void visit(SynchronizedStatement *s) { visit((Statement *)s); } visit(WithStatement * s)341 virtual void visit(WithStatement *s) { visit((Statement *)s); } visit(TryCatchStatement * s)342 virtual void visit(TryCatchStatement *s) { visit((Statement *)s); } visit(TryFinallyStatement * s)343 virtual void visit(TryFinallyStatement *s) { visit((Statement *)s); } visit(ScopeGuardStatement * s)344 virtual void visit(ScopeGuardStatement *s) { visit((Statement *)s); } visit(ThrowStatement * s)345 virtual void visit(ThrowStatement *s) { visit((Statement *)s); } visit(DebugStatement * s)346 virtual void visit(DebugStatement *s) { visit((Statement *)s); } visit(GotoStatement * s)347 virtual void visit(GotoStatement *s) { visit((Statement *)s); } visit(LabelStatement * s)348 virtual void visit(LabelStatement *s) { visit((Statement *)s); } visit(AsmStatement * s)349 virtual void visit(AsmStatement *s) { visit((Statement *)s); } visit(InlineAsmStatement * s)350 virtual void visit(InlineAsmStatement *s) { visit((AsmStatement *)s); } visit(GccAsmStatement * s)351 virtual void visit(GccAsmStatement *s) { visit((AsmStatement *)s); } visit(CompoundAsmStatement * s)352 virtual void visit(CompoundAsmStatement *s) { visit((CompoundStatement *)s); } visit(ImportStatement * s)353 virtual void visit(ImportStatement *s) { visit((Statement *)s); } 354 visit(Type *)355 virtual void visit(Type *) { assert(0); } visit(TypeError * t)356 virtual void visit(TypeError *t) { visit((Type *)t); } visit(TypeNext * t)357 virtual void visit(TypeNext *t) { visit((Type *)t); } visit(TypeBasic * t)358 virtual void visit(TypeBasic *t) { visit((Type *)t); } visit(TypeVector * t)359 virtual void visit(TypeVector *t) { visit((Type *)t); } visit(TypeArray * t)360 virtual void visit(TypeArray *t) { visit((TypeNext *)t); } visit(TypeSArray * t)361 virtual void visit(TypeSArray *t) { visit((TypeArray *)t); } visit(TypeDArray * t)362 virtual void visit(TypeDArray *t) { visit((TypeArray *)t); } visit(TypeAArray * t)363 virtual void visit(TypeAArray *t) { visit((TypeArray *)t); } visit(TypePointer * t)364 virtual void visit(TypePointer *t) { visit((TypeNext *)t); } visit(TypeReference * t)365 virtual void visit(TypeReference *t) { visit((TypeNext *)t); } visit(TypeFunction * t)366 virtual void visit(TypeFunction *t) { visit((TypeNext *)t); } visit(TypeDelegate * t)367 virtual void visit(TypeDelegate *t) { visit((TypeNext *)t); } visit(TypeQualified * t)368 virtual void visit(TypeQualified *t) { visit((Type *)t); } visit(TypeIdentifier * t)369 virtual void visit(TypeIdentifier *t) { visit((TypeQualified *)t); } visit(TypeInstance * t)370 virtual void visit(TypeInstance *t) { visit((TypeQualified *)t); } visit(TypeTypeof * t)371 virtual void visit(TypeTypeof *t) { visit((TypeQualified *)t); } visit(TypeReturn * t)372 virtual void visit(TypeReturn *t) { visit((TypeQualified *)t); } visit(TypeStruct * t)373 virtual void visit(TypeStruct *t) { visit((Type *)t); } visit(TypeEnum * t)374 virtual void visit(TypeEnum *t) { visit((Type *)t); } visit(TypeClass * t)375 virtual void visit(TypeClass *t) { visit((Type *)t); } visit(TypeTuple * t)376 virtual void visit(TypeTuple *t) { visit((Type *)t); } visit(TypeSlice * t)377 virtual void visit(TypeSlice *t) { visit((TypeNext *)t); } visit(TypeNull * t)378 virtual void visit(TypeNull *t) { visit((Type *)t); } visit(TypeNoreturn * t)379 virtual void visit(TypeNoreturn *t) { visit((Type *)t); } visit(TypeTraits * t)380 virtual void visit(TypeTraits *t) { visit((Type *)t); } visit(TypeMixin * t)381 virtual void visit(TypeMixin *t) { visit((Type *)t); } 382 visit(Dsymbol *)383 virtual void visit(Dsymbol *) { assert(0); } 384 visit(StaticAssert * s)385 virtual void visit(StaticAssert *s) { visit((Dsymbol *)s); } visit(DebugSymbol * s)386 virtual void visit(DebugSymbol *s) { visit((Dsymbol *)s); } visit(VersionSymbol * s)387 virtual void visit(VersionSymbol *s) { visit((Dsymbol *)s); } visit(EnumMember * s)388 virtual void visit(EnumMember *s) { visit((VarDeclaration *)s); } visit(Import * s)389 virtual void visit(Import *s) { visit((Dsymbol *)s); } visit(OverloadSet * s)390 virtual void visit(OverloadSet *s) { visit((Dsymbol *)s); } visit(LabelDsymbol * s)391 virtual void visit(LabelDsymbol *s) { visit((Dsymbol *)s); } visit(AliasThis * s)392 virtual void visit(AliasThis *s) { visit((Dsymbol *)s); } 393 visit(AttribDeclaration * s)394 virtual void visit(AttribDeclaration *s) { visit((Dsymbol *)s); } visit(StorageClassDeclaration * s)395 virtual void visit(StorageClassDeclaration *s) { visit((AttribDeclaration *)s); } visit(DeprecatedDeclaration * s)396 virtual void visit(DeprecatedDeclaration *s) { visit((StorageClassDeclaration *)s); } visit(LinkDeclaration * s)397 virtual void visit(LinkDeclaration *s) { visit((AttribDeclaration *)s); } visit(CPPMangleDeclaration * s)398 virtual void visit(CPPMangleDeclaration *s) { visit((AttribDeclaration *)s); } visit(ProtDeclaration * s)399 virtual void visit(ProtDeclaration *s) { visit((AttribDeclaration *)s); } visit(AlignDeclaration * s)400 virtual void visit(AlignDeclaration *s) { visit((AttribDeclaration *)s); } visit(AnonDeclaration * s)401 virtual void visit(AnonDeclaration *s) { visit((AttribDeclaration *)s); } visit(PragmaDeclaration * s)402 virtual void visit(PragmaDeclaration *s) { visit((AttribDeclaration *)s); } visit(ConditionalDeclaration * s)403 virtual void visit(ConditionalDeclaration *s) { visit((AttribDeclaration *)s); } visit(StaticIfDeclaration * s)404 virtual void visit(StaticIfDeclaration *s) { visit((ConditionalDeclaration *)s); } visit(StaticForeachDeclaration * s)405 virtual void visit(StaticForeachDeclaration *s) { visit((AttribDeclaration *)s); } visit(CompileDeclaration * s)406 virtual void visit(CompileDeclaration *s) { visit((AttribDeclaration *)s); } visit(UserAttributeDeclaration * s)407 virtual void visit(UserAttributeDeclaration *s) { visit((AttribDeclaration *)s); } visit(ForwardingAttribDeclaration * s)408 virtual void visit(ForwardingAttribDeclaration *s) { visit((AttribDeclaration *)s); } 409 visit(ScopeDsymbol * s)410 virtual void visit(ScopeDsymbol *s) { visit((Dsymbol *)s); } visit(TemplateDeclaration * s)411 virtual void visit(TemplateDeclaration *s) { visit((ScopeDsymbol *)s); } visit(TemplateInstance * s)412 virtual void visit(TemplateInstance *s) { visit((ScopeDsymbol *)s); } visit(TemplateMixin * s)413 virtual void visit(TemplateMixin *s) { visit((TemplateInstance *)s); } visit(EnumDeclaration * s)414 virtual void visit(EnumDeclaration *s) { visit((ScopeDsymbol *)s); } visit(Package * s)415 virtual void visit(Package *s) { visit((ScopeDsymbol *)s); } visit(Module * s)416 virtual void visit(Module *s) { visit((Package *)s); } visit(WithScopeSymbol * s)417 virtual void visit(WithScopeSymbol *s) { visit((ScopeDsymbol *)s); } visit(ArrayScopeSymbol * s)418 virtual void visit(ArrayScopeSymbol *s) { visit((ScopeDsymbol *)s); } visit(Nspace * s)419 virtual void visit(Nspace *s) { visit((ScopeDsymbol *)s); } 420 visit(AggregateDeclaration * s)421 virtual void visit(AggregateDeclaration *s) { visit((ScopeDsymbol *)s); } visit(StructDeclaration * s)422 virtual void visit(StructDeclaration *s) { visit((AggregateDeclaration *)s); } visit(UnionDeclaration * s)423 virtual void visit(UnionDeclaration *s) { visit((StructDeclaration *)s); } visit(ClassDeclaration * s)424 virtual void visit(ClassDeclaration *s) { visit((AggregateDeclaration *)s); } visit(InterfaceDeclaration * s)425 virtual void visit(InterfaceDeclaration *s) { visit((ClassDeclaration *)s); } 426 visit(Declaration * s)427 virtual void visit(Declaration *s) { visit((Dsymbol *)s); } visit(TupleDeclaration * s)428 virtual void visit(TupleDeclaration *s) { visit((Declaration *)s); } visit(AliasDeclaration * s)429 virtual void visit(AliasDeclaration *s) { visit((Declaration *)s); } visit(OverDeclaration * s)430 virtual void visit(OverDeclaration *s) { visit((Declaration *)s); } visit(VarDeclaration * s)431 virtual void visit(VarDeclaration *s) { visit((Declaration *)s); } visit(SymbolDeclaration * s)432 virtual void visit(SymbolDeclaration *s) { visit((Declaration *)s); } visit(ThisDeclaration * s)433 virtual void visit(ThisDeclaration *s) { visit((VarDeclaration *)s); } 434 visit(TypeInfoDeclaration * s)435 virtual void visit(TypeInfoDeclaration *s) { visit((VarDeclaration *)s); } visit(TypeInfoStructDeclaration * s)436 virtual void visit(TypeInfoStructDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoClassDeclaration * s)437 virtual void visit(TypeInfoClassDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoInterfaceDeclaration * s)438 virtual void visit(TypeInfoInterfaceDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoPointerDeclaration * s)439 virtual void visit(TypeInfoPointerDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoArrayDeclaration * s)440 virtual void visit(TypeInfoArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoStaticArrayDeclaration * s)441 virtual void visit(TypeInfoStaticArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoAssociativeArrayDeclaration * s)442 virtual void visit(TypeInfoAssociativeArrayDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoEnumDeclaration * s)443 virtual void visit(TypeInfoEnumDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoFunctionDeclaration * s)444 virtual void visit(TypeInfoFunctionDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoDelegateDeclaration * s)445 virtual void visit(TypeInfoDelegateDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoTupleDeclaration * s)446 virtual void visit(TypeInfoTupleDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoConstDeclaration * s)447 virtual void visit(TypeInfoConstDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoInvariantDeclaration * s)448 virtual void visit(TypeInfoInvariantDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoSharedDeclaration * s)449 virtual void visit(TypeInfoSharedDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoWildDeclaration * s)450 virtual void visit(TypeInfoWildDeclaration *s) { visit((TypeInfoDeclaration *)s); } visit(TypeInfoVectorDeclaration * s)451 virtual void visit(TypeInfoVectorDeclaration *s) { visit((TypeInfoDeclaration *)s); } 452 visit(FuncDeclaration * s)453 virtual void visit(FuncDeclaration *s) { visit((Declaration *)s); } visit(FuncAliasDeclaration * s)454 virtual void visit(FuncAliasDeclaration *s) { visit((FuncDeclaration *)s); } visit(FuncLiteralDeclaration * s)455 virtual void visit(FuncLiteralDeclaration *s) { visit((FuncDeclaration *)s); } visit(CtorDeclaration * s)456 virtual void visit(CtorDeclaration *s) { visit((FuncDeclaration *)s); } visit(PostBlitDeclaration * s)457 virtual void visit(PostBlitDeclaration *s) { visit((FuncDeclaration *)s); } visit(DtorDeclaration * s)458 virtual void visit(DtorDeclaration *s) { visit((FuncDeclaration *)s); } visit(StaticCtorDeclaration * s)459 virtual void visit(StaticCtorDeclaration *s) { visit((FuncDeclaration *)s); } visit(SharedStaticCtorDeclaration * s)460 virtual void visit(SharedStaticCtorDeclaration *s) { visit((StaticCtorDeclaration *)s); } visit(StaticDtorDeclaration * s)461 virtual void visit(StaticDtorDeclaration *s) { visit((FuncDeclaration *)s); } visit(SharedStaticDtorDeclaration * s)462 virtual void visit(SharedStaticDtorDeclaration *s) { visit((StaticDtorDeclaration *)s); } visit(InvariantDeclaration * s)463 virtual void visit(InvariantDeclaration *s) { visit((FuncDeclaration *)s); } visit(UnitTestDeclaration * s)464 virtual void visit(UnitTestDeclaration *s) { visit((FuncDeclaration *)s); } visit(NewDeclaration * s)465 virtual void visit(NewDeclaration *s) { visit((FuncDeclaration *)s); } visit(DeleteDeclaration * s)466 virtual void visit(DeleteDeclaration *s) { visit((FuncDeclaration *)s); } 467 visit(Initializer *)468 virtual void visit(Initializer *) { assert(0); } visit(VoidInitializer * i)469 virtual void visit(VoidInitializer *i) { visit((Initializer *)i); } visit(ErrorInitializer * i)470 virtual void visit(ErrorInitializer *i) { visit((Initializer *)i); } visit(StructInitializer * i)471 virtual void visit(StructInitializer *i) { visit((Initializer *)i); } visit(ArrayInitializer * i)472 virtual void visit(ArrayInitializer *i) { visit((Initializer *)i); } visit(ExpInitializer * i)473 virtual void visit(ExpInitializer *i) { visit((Initializer *)i); } 474 visit(Expression *)475 virtual void visit(Expression *) { assert(0); } visit(IntegerExp * e)476 virtual void visit(IntegerExp *e) { visit((Expression *)e); } visit(ErrorExp * e)477 virtual void visit(ErrorExp *e) { visit((Expression *)e); } visit(RealExp * e)478 virtual void visit(RealExp *e) { visit((Expression *)e); } visit(ComplexExp * e)479 virtual void visit(ComplexExp *e) { visit((Expression *)e); } visit(IdentifierExp * e)480 virtual void visit(IdentifierExp *e) { visit((Expression *)e); } visit(DollarExp * e)481 virtual void visit(DollarExp *e) { visit((IdentifierExp *)e); } visit(DsymbolExp * e)482 virtual void visit(DsymbolExp *e) { visit((Expression *)e); } visit(ThisExp * e)483 virtual void visit(ThisExp *e) { visit((Expression *)e); } visit(SuperExp * e)484 virtual void visit(SuperExp *e) { visit((ThisExp *)e); } visit(NullExp * e)485 virtual void visit(NullExp *e) { visit((Expression *)e); } visit(StringExp * e)486 virtual void visit(StringExp *e) { visit((Expression *)e); } visit(TupleExp * e)487 virtual void visit(TupleExp *e) { visit((Expression *)e); } visit(ArrayLiteralExp * e)488 virtual void visit(ArrayLiteralExp *e) { visit((Expression *)e); } visit(AssocArrayLiteralExp * e)489 virtual void visit(AssocArrayLiteralExp *e) { visit((Expression *)e); } visit(StructLiteralExp * e)490 virtual void visit(StructLiteralExp *e) { visit((Expression *)e); } visit(TypeExp * e)491 virtual void visit(TypeExp *e) { visit((Expression *)e); } visit(ScopeExp * e)492 virtual void visit(ScopeExp *e) { visit((Expression *)e); } visit(TemplateExp * e)493 virtual void visit(TemplateExp *e) { visit((Expression *)e); } visit(NewExp * e)494 virtual void visit(NewExp *e) { visit((Expression *)e); } visit(NewAnonClassExp * e)495 virtual void visit(NewAnonClassExp *e) { visit((Expression *)e); } visit(SymbolExp * e)496 virtual void visit(SymbolExp *e) { visit((Expression *)e); } visit(SymOffExp * e)497 virtual void visit(SymOffExp *e) { visit((SymbolExp *)e); } visit(VarExp * e)498 virtual void visit(VarExp *e) { visit((SymbolExp *)e); } visit(OverExp * e)499 virtual void visit(OverExp *e) { visit((Expression *)e); } visit(FuncExp * e)500 virtual void visit(FuncExp *e) { visit((Expression *)e); } visit(DeclarationExp * e)501 virtual void visit(DeclarationExp *e) { visit((Expression *)e); } visit(TypeidExp * e)502 virtual void visit(TypeidExp *e) { visit((Expression *)e); } visit(TraitsExp * e)503 virtual void visit(TraitsExp *e) { visit((Expression *)e); } visit(HaltExp * e)504 virtual void visit(HaltExp *e) { visit((Expression *)e); } visit(IsExp * e)505 virtual void visit(IsExp *e) { visit((Expression *)e); } visit(UnaExp * e)506 virtual void visit(UnaExp *e) { visit((Expression *)e); } visit(BinExp * e)507 virtual void visit(BinExp *e) { visit((Expression *)e); } visit(BinAssignExp * e)508 virtual void visit(BinAssignExp *e) { visit((BinExp *)e); } visit(CompileExp * e)509 virtual void visit(CompileExp *e) { visit((UnaExp *)e); } visit(ImportExp * e)510 virtual void visit(ImportExp *e) { visit((UnaExp *)e); } visit(AssertExp * e)511 virtual void visit(AssertExp *e) { visit((UnaExp *)e); } visit(DotIdExp * e)512 virtual void visit(DotIdExp *e) { visit((UnaExp *)e); } visit(DotTemplateExp * e)513 virtual void visit(DotTemplateExp *e) { visit((UnaExp *)e); } visit(DotVarExp * e)514 virtual void visit(DotVarExp *e) { visit((UnaExp *)e); } visit(DotTemplateInstanceExp * e)515 virtual void visit(DotTemplateInstanceExp *e) { visit((UnaExp *)e); } visit(DelegateExp * e)516 virtual void visit(DelegateExp *e) { visit((UnaExp *)e); } visit(DotTypeExp * e)517 virtual void visit(DotTypeExp *e) { visit((UnaExp *)e); } visit(CallExp * e)518 virtual void visit(CallExp *e) { visit((UnaExp *)e); } visit(AddrExp * e)519 virtual void visit(AddrExp *e) { visit((UnaExp *)e); } visit(PtrExp * e)520 virtual void visit(PtrExp *e) { visit((UnaExp *)e); } visit(NegExp * e)521 virtual void visit(NegExp *e) { visit((UnaExp *)e); } visit(UAddExp * e)522 virtual void visit(UAddExp *e) { visit((UnaExp *)e); } visit(ComExp * e)523 virtual void visit(ComExp *e) { visit((UnaExp *)e); } visit(NotExp * e)524 virtual void visit(NotExp *e) { visit((UnaExp *)e); } visit(DeleteExp * e)525 virtual void visit(DeleteExp *e) { visit((UnaExp *)e); } visit(CastExp * e)526 virtual void visit(CastExp *e) { visit((UnaExp *)e); } visit(VectorExp * e)527 virtual void visit(VectorExp *e) { visit((UnaExp *)e); } visit(VectorArrayExp * e)528 virtual void visit(VectorArrayExp *e) { visit((UnaExp *)e); } visit(SliceExp * e)529 virtual void visit(SliceExp *e) { visit((UnaExp *)e); } visit(ArrayLengthExp * e)530 virtual void visit(ArrayLengthExp *e) { visit((UnaExp *)e); } visit(IntervalExp * e)531 virtual void visit(IntervalExp *e) { visit((Expression *)e); } visit(DelegatePtrExp * e)532 virtual void visit(DelegatePtrExp *e) { visit((UnaExp *)e); } visit(DelegateFuncptrExp * e)533 virtual void visit(DelegateFuncptrExp *e) { visit((UnaExp *)e); } visit(ArrayExp * e)534 virtual void visit(ArrayExp *e) { visit((UnaExp *)e); } visit(DotExp * e)535 virtual void visit(DotExp *e) { visit((BinExp *)e); } visit(CommaExp * e)536 virtual void visit(CommaExp *e) { visit((BinExp *)e); } visit(IndexExp * e)537 virtual void visit(IndexExp *e) { visit((BinExp *)e); } visit(PostExp * e)538 virtual void visit(PostExp *e) { visit((BinExp *)e); } visit(PreExp * e)539 virtual void visit(PreExp *e) { visit((UnaExp *)e); } visit(AssignExp * e)540 virtual void visit(AssignExp *e) { visit((BinExp *)e); } visit(ConstructExp * e)541 virtual void visit(ConstructExp *e) { visit((AssignExp *)e); } visit(BlitExp * e)542 virtual void visit(BlitExp *e) { visit((AssignExp *)e); } visit(AddAssignExp * e)543 virtual void visit(AddAssignExp *e) { visit((BinAssignExp *)e); } visit(MinAssignExp * e)544 virtual void visit(MinAssignExp *e) { visit((BinAssignExp *)e); } visit(MulAssignExp * e)545 virtual void visit(MulAssignExp *e) { visit((BinAssignExp *)e); } visit(DivAssignExp * e)546 virtual void visit(DivAssignExp *e) { visit((BinAssignExp *)e); } visit(ModAssignExp * e)547 virtual void visit(ModAssignExp *e) { visit((BinAssignExp *)e); } visit(AndAssignExp * e)548 virtual void visit(AndAssignExp *e) { visit((BinAssignExp *)e); } visit(OrAssignExp * e)549 virtual void visit(OrAssignExp *e) { visit((BinAssignExp *)e); } visit(XorAssignExp * e)550 virtual void visit(XorAssignExp *e) { visit((BinAssignExp *)e); } visit(PowAssignExp * e)551 virtual void visit(PowAssignExp *e) { visit((BinAssignExp *)e); } visit(ShlAssignExp * e)552 virtual void visit(ShlAssignExp *e) { visit((BinAssignExp *)e); } visit(ShrAssignExp * e)553 virtual void visit(ShrAssignExp *e) { visit((BinAssignExp *)e); } visit(UshrAssignExp * e)554 virtual void visit(UshrAssignExp *e) { visit((BinAssignExp *)e); } visit(CatAssignExp * e)555 virtual void visit(CatAssignExp *e) { visit((BinAssignExp *)e); } visit(AddExp * e)556 virtual void visit(AddExp *e) { visit((BinExp *)e); } visit(MinExp * e)557 virtual void visit(MinExp *e) { visit((BinExp *)e); } visit(CatExp * e)558 virtual void visit(CatExp *e) { visit((BinExp *)e); } visit(MulExp * e)559 virtual void visit(MulExp *e) { visit((BinExp *)e); } visit(DivExp * e)560 virtual void visit(DivExp *e) { visit((BinExp *)e); } visit(ModExp * e)561 virtual void visit(ModExp *e) { visit((BinExp *)e); } visit(PowExp * e)562 virtual void visit(PowExp *e) { visit((BinExp *)e); } visit(ShlExp * e)563 virtual void visit(ShlExp *e) { visit((BinExp *)e); } visit(ShrExp * e)564 virtual void visit(ShrExp *e) { visit((BinExp *)e); } visit(UshrExp * e)565 virtual void visit(UshrExp *e) { visit((BinExp *)e); } visit(AndExp * e)566 virtual void visit(AndExp *e) { visit((BinExp *)e); } visit(OrExp * e)567 virtual void visit(OrExp *e) { visit((BinExp *)e); } visit(XorExp * e)568 virtual void visit(XorExp *e) { visit((BinExp *)e); } visit(LogicalExp * e)569 virtual void visit(LogicalExp *e) { visit((BinExp *)e); } visit(CmpExp * e)570 virtual void visit(CmpExp *e) { visit((BinExp *)e); } visit(InExp * e)571 virtual void visit(InExp *e) { visit((BinExp *)e); } visit(RemoveExp * e)572 virtual void visit(RemoveExp *e) { visit((BinExp *)e); } visit(EqualExp * e)573 virtual void visit(EqualExp *e) { visit((BinExp *)e); } visit(IdentityExp * e)574 virtual void visit(IdentityExp *e) { visit((BinExp *)e); } visit(CondExp * e)575 virtual void visit(CondExp *e) { visit((BinExp *)e); } visit(DefaultInitExp * e)576 virtual void visit(DefaultInitExp *e) { visit((Expression *)e); } visit(FileInitExp * e)577 virtual void visit(FileInitExp *e) { visit((DefaultInitExp *)e); } visit(LineInitExp * e)578 virtual void visit(LineInitExp *e) { visit((DefaultInitExp *)e); } visit(ModuleInitExp * e)579 virtual void visit(ModuleInitExp *e) { visit((DefaultInitExp *)e); } visit(FuncInitExp * e)580