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