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