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