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