From bcc7fd4eba8315b813a4adbdfc298c8f1b540f4e Mon Sep 17 00:00:00 2001 From: RazvanN7 Date: Tue, 5 Dec 2017 14:31:56 +0200 Subject: [PATCH 1/4] Integrate ASTBase visitor with the compiler visitor --- src/ddmd/apply.d | 2 +- src/ddmd/argtypes.d | 2 +- src/ddmd/arrayop.d | 2 +- src/ddmd/astbase.d | 9 +- src/ddmd/astbasevisitor.d | 280 ------ src/ddmd/astcodegen.d | 1 + src/ddmd/asttypename.d | 2 +- src/ddmd/blockexit.d | 2 +- src/ddmd/canthrow.d | 2 +- src/ddmd/cppmangle.d | 2 +- src/ddmd/cppmanglewin.d | 2 +- src/ddmd/dcast.d | 10 +- src/ddmd/delegatize.d | 4 +- src/ddmd/dinterpret.d | 6 +- src/ddmd/dmangle.d | 2 +- src/ddmd/doc.d | 4 +- src/ddmd/dstruct.d | 2 +- src/ddmd/dsymbolsem.d | 6 +- src/ddmd/dtemplate.d | 4 +- src/ddmd/e2ir.d | 2 +- src/ddmd/escape.d | 4 +- src/ddmd/expression.d | 2 +- src/ddmd/expressionsem.d | 2 +- src/ddmd/hdrgen.d | 2 +- src/ddmd/initsem.d | 6 +- src/ddmd/inline.d | 4 +- src/ddmd/inlinecost.d | 4 +- src/ddmd/json.d | 2 +- src/ddmd/nogc.d | 2 +- src/ddmd/opover.d | 6 +- src/ddmd/optimize.d | 2 +- src/ddmd/parsetimevisitor.d | 278 ++++++ src/ddmd/permissivevisitor.d | 23 +- src/ddmd/printast.d | 2 +- src/ddmd/s2ir.d | 2 +- src/ddmd/sapply.d | 2 +- src/ddmd/sideeffect.d | 4 +- src/ddmd/statement.d | 8 +- src/ddmd/statement_rewrite_walker.d | 2 +- src/ddmd/statementsem.d | 2 +- src/ddmd/strictvisitor.d | 431 ++++---- src/ddmd/templateparamsem.d | 2 +- src/ddmd/tocsym.d | 2 +- src/ddmd/toctype.d | 2 +- src/ddmd/tocvdebug.d | 2 +- src/ddmd/todt.d | 8 +- src/ddmd/toobj.d | 2 +- src/ddmd/traits.d | 2 +- src/ddmd/transitivevisitor.d | 335 ++++--- src/ddmd/typesem.d | 4 +- src/ddmd/typinf.d | 2 +- src/ddmd/visitor.d | 1435 ++------------------------- src/examples/avg.d | 10 +- src/examples/impvisitor.d | 17 +- src/examples/test_parser.d | 2 +- src/posix.mak | 4 +- src/win32.mak | 2 +- 57 files changed, 826 insertions(+), 2141 deletions(-) delete mode 100644 src/ddmd/astbasevisitor.d create mode 100644 src/ddmd/parsetimevisitor.d diff --git a/src/ddmd/apply.d b/src/ddmd/apply.d index 7e772e9f51b6..ffea9eae32db 100644 --- a/src/ddmd/apply.d +++ b/src/ddmd/apply.d @@ -29,7 +29,7 @@ import ddmd.visitor; */ private extern (C++) final class PostorderExpressionVisitor : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: StoppableVisitor v; diff --git a/src/ddmd/argtypes.d b/src/ddmd/argtypes.d index e231aaf0f02f..d97d64967309 100644 --- a/src/ddmd/argtypes.d +++ b/src/ddmd/argtypes.d @@ -32,7 +32,7 @@ extern (C++) TypeTuple toArgTypes(Type t) { extern (C++) final class ToArgTypes : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: TypeTuple result; diff --git a/src/ddmd/arrayop.d b/src/ddmd/arrayop.d index d3c3639fae75..66d4255a732e 100644 --- a/src/ddmd/arrayop.d +++ b/src/ddmd/arrayop.d @@ -178,7 +178,7 @@ extern (C++) void buildArrayOp(Scope* sc, Expression e, Objects* tiargs, Express { extern (C++) final class BuildArrayOpVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Scope* sc; Objects* tiargs; Expressions* args; diff --git a/src/ddmd/astbase.d b/src/ddmd/astbase.d index fdb02f6c8bd7..b82861196ce5 100644 --- a/src/ddmd/astbase.d +++ b/src/ddmd/astbase.d @@ -2,7 +2,7 @@ module ddmd.astbase; // Online documentation: https://dlang.org/phobos/ddmd_astbase.html -import ddmd.astbasevisitor; +import ddmd.parsetimevisitor; /** The ASTBase family defines a family of AST nodes appropriate for parsing with * no semantic information. It defines all the AST nodes that the parser needs @@ -338,6 +338,8 @@ struct ASTBase alias RECtracing = AliasThisRec.RECtracing; alias RECtracingDT = AliasThisRec.RECtracingDT; + alias Visitor = ParseTimeVisitor!ASTBase; + extern (C++) class Dsymbol : RootObject { Loc loc; @@ -5940,11 +5942,6 @@ struct ASTBase this.aggrfe = aggrfe; this.rangefe = rangefe; } - - void accept(Visitor v) - { - v.visit(this); - } } extern (C++) final class StaticIfCondition : Condition diff --git a/src/ddmd/astbasevisitor.d b/src/ddmd/astbasevisitor.d deleted file mode 100644 index 146357b07d50..000000000000 --- a/src/ddmd/astbasevisitor.d +++ /dev/null @@ -1,280 +0,0 @@ -module ddmd.astbasevisitor; - -// Online documentation: https://dlang.org/phobos/ddmd_astbasevisitor.html - -import ddmd.astbase; - -/** Basic and dumm visitor which implements a visit method for each AST node - * implemented in ASTBase. This visitor is the parent of strict, transitive - * and permissive visitors. - */ -class Visitor -{ - void visit(ASTBase.Dsymbol) { assert(0); } - void visit(ASTBase.Parameter) { assert(0); } - void visit(ASTBase.Statement) { assert(0); } - void visit(ASTBase.Type) { assert(0); } - void visit(ASTBase.Expression) { assert(0); } - void visit(ASTBase.TemplateParameter) { assert(0); } - void visit(ASTBase.Condition) { assert(0); } - void visit(ASTBase.StaticForeach) { assert(0); } - void visit(ASTBase.Initializer) { assert(0); } - - //======================================================================================= - // Dsymbols - void visit(ASTBase.AliasThis s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.Declaration s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.ScopeDsymbol s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.Import s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.AttribDeclaration s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.StaticAssert s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.DebugSymbol s) { visit(cast(ASTBase.Dsymbol)s); } - void visit(ASTBase.VersionSymbol s) { visit(cast(ASTBase.Dsymbol)s); } - - // ScopeDsymbols - void visit(ASTBase.Package s) { visit(cast(ASTBase.ScopeDsymbol)s); } - void visit(ASTBase.EnumDeclaration s) { visit(cast(ASTBase.ScopeDsymbol)s); } - void visit(ASTBase.AggregateDeclaration s) { visit(cast(ASTBase.ScopeDsymbol)s); } - void visit(ASTBase.TemplateDeclaration s) { visit(cast(ASTBase.ScopeDsymbol)s); } - void visit(ASTBase.TemplateInstance s) { visit(cast(ASTBase.ScopeDsymbol)s); } - void visit(ASTBase.Nspace s) { visit(cast(ASTBase.ScopeDsymbol)s); } - - //========================================================================================= - // Declarations - void visit(ASTBase.VarDeclaration s) { visit(cast(ASTBase.Declaration)s); } - void visit(ASTBase.FuncDeclaration s) { visit(cast(ASTBase.Declaration)s); } - void visit(ASTBase.AliasDeclaration s) { visit(cast(ASTBase.Declaration)s); } - void visit(ASTBase.TupleDeclaration s) { visit(cast(ASTBase.Declaration)s); } - - // FuncDeclarations - void visit(ASTBase.FuncLiteralDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.PostBlitDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.CtorDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.DtorDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.InvariantDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.UnitTestDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.NewDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.DeleteDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.StaticCtorDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.StaticDtorDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.SharedStaticCtorDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - void visit(ASTBase.SharedStaticDtorDeclaration s) { visit(cast(ASTBase.FuncDeclaration)s); } - - // AttribDeclarations - void visit(ASTBase.CompileDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.UserAttributeDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.LinkDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.AnonDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.AlignDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.CPPMangleDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.ProtDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.PragmaDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.StorageClassDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - void visit(ASTBase.ConditionalDeclaration s) { visit(cast(ASTBase.AttribDeclaration)s); } - - //============================================================================================== - // Miscellaneous - void visit(ASTBase.DeprecatedDeclaration s) { visit(cast(ASTBase.StorageClassDeclaration)s); } - void visit(ASTBase.StaticIfDeclaration s) { visit(cast(ASTBase.ConditionalDeclaration)s); } - void visit(ASTBase.StaticForeachDeclaration s) { visit(cast(ASTBase.ConditionalDeclaration)s); } - void visit(ASTBase.EnumMember s) { visit(cast(ASTBase.VarDeclaration)s); } - void visit(ASTBase.Module s) { visit(cast(ASTBase.Package)s); } - void visit(ASTBase.StructDeclaration s) { visit(cast(ASTBase.AggregateDeclaration)s); } - void visit(ASTBase.UnionDeclaration s) { visit(cast(ASTBase.StructDeclaration)s); } - void visit(ASTBase.ClassDeclaration s) { visit(cast(ASTBase.AggregateDeclaration)s); } - void visit(ASTBase.InterfaceDeclaration s) { visit(cast(ASTBase.ClassDeclaration)s); } - void visit(ASTBase.TemplateMixin s) { visit(cast(ASTBase.TemplateInstance)s); } - - //============================================================================================ - // Statements - void visit(ASTBase.ImportStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ScopeStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ReturnStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.LabelStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.StaticAssertStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.CompileStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.WhileStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ForStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.DoStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ForeachRangeStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ForeachStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.IfStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.OnScopeStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ConditionalStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.StaticForeachStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.PragmaStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.SwitchStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.CaseRangeStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.CaseStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.DefaultStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.BreakStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ContinueStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.GotoDefaultStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.GotoCaseStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.GotoStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.SynchronizedStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.WithStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.TryCatchStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.TryFinallyStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ThrowStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.AsmStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.ExpStatement s) { visit(cast(ASTBase.Statement)s); } - void visit(ASTBase.CompoundStatement s) { visit(cast(ASTBase.Statement)s); } - - // CompoundStatements - void visit(ASTBase.CompoundDeclarationStatement s) { visit(cast(ASTBase.CompoundStatement)s); } - void visit(ASTBase.CompoundAsmStatement s) { visit(cast(ASTBase.CompoundStatement)s); } - - //========================================================================================= - // Types - void visit(ASTBase.TypeBasic t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeError t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeNull t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeVector t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeEnum t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeTuple t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeClass t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeStruct t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeNext t) { visit(cast(ASTBase.Type)t); } - void visit(ASTBase.TypeQualified t) { visit(cast(ASTBase.Type)t); } - - // TypeNext - void visit(ASTBase.TypeReference t) { visit(cast(ASTBase.TypeNext)t); } - void visit(ASTBase.TypeSlice t) { visit(cast(ASTBase.TypeNext)t); } - void visit(ASTBase.TypeDelegate t) { visit(cast(ASTBase.TypeNext)t); } - void visit(ASTBase.TypePointer t) { visit(cast(ASTBase.TypeNext)t); } - void visit(ASTBase.TypeFunction t) { visit(cast(ASTBase.TypeNext)t); } - void visit(ASTBase.TypeArray t) { visit(cast(ASTBase.TypeNext)t); } - - // TypeArray - void visit(ASTBase.TypeDArray t) { visit(cast(ASTBase.TypeArray)t); } - void visit(ASTBase.TypeAArray t) { visit(cast(ASTBase.TypeArray)t); } - void visit(ASTBase.TypeSArray t) { visit(cast(ASTBase.TypeArray)t); } - - // TypeQualified - void visit(ASTBase.TypeIdentifier t) { visit(cast(ASTBase.TypeQualified)t); } - void visit(ASTBase.TypeReturn t) { visit(cast(ASTBase.TypeQualified)t); } - void visit(ASTBase.TypeTypeof t) { visit(cast(ASTBase.TypeQualified)t); } - void visit(ASTBase.TypeInstance t) { visit(cast(ASTBase.TypeQualified)t); } - - //================================================================================= - // Expressions - void visit(ASTBase.DeclarationExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.IntegerExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.NewAnonClassExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.IsExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.RealExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.NullExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.TypeidExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.TraitsExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.StringExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.NewExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.AssocArrayLiteralExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.ArrayLiteralExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.FuncExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.IntervalExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.TypeExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.ScopeExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.IdentifierExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.UnaExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.DefaultInitExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.BinExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.DsymbolExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.TemplateExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.SymbolExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.TupleExp e) { visit(cast(ASTBase.Expression)e); } - void visit(ASTBase.ThisExp e) { visit(cast(ASTBase.Expression)e); } - - // Miscellaneous - void visit(ASTBase.VarExp e) { visit(cast(ASTBase.SymbolExp)e); } - void visit(ASTBase.DollarExp e) { visit(cast(ASTBase.IdentifierExp)e); } - void visit(ASTBase.SuperExp e) { visit(cast(ASTBase.ThisExp)e); } - - // UnaExp - void visit(ASTBase.AddrExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.PreExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.PtrExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.NegExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.UAddExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.NotExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.ComExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.DeleteExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.CastExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.CallExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.DotIdExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.AssertExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.CompileExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.ImportExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.DotTemplateInstanceExp e) { visit(cast(ASTBase.UnaExp)e); } - void visit(ASTBase.ArrayExp e) { visit(cast(ASTBase.UnaExp)e); } - - // DefaultInitExp - void visit(ASTBase.FuncInitExp e) { visit(cast(ASTBase.DefaultInitExp)e); } - void visit(ASTBase.PrettyFuncInitExp e) { visit(cast(ASTBase.DefaultInitExp)e); } - void visit(ASTBase.FileInitExp e) { visit(cast(ASTBase.DefaultInitExp)e); } - void visit(ASTBase.LineInitExp e) { visit(cast(ASTBase.DefaultInitExp)e); } - void visit(ASTBase.ModuleInitExp e) { visit(cast(ASTBase.DefaultInitExp)e); } - - // BinExp - void visit(ASTBase.CommaExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.PostExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.PowExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.MulExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.DivExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.ModExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.AddExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.MinExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.CatExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.ShlExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.ShrExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.UshrExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.EqualExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.InExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.IdentityExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.CmpExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.AndExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.XorExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.OrExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.LogicalExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.CondExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.AssignExp e) { visit(cast(ASTBase.BinExp)e); } - void visit(ASTBase.BinAssignExp e) { visit(cast(ASTBase.BinExp)e); } - - // BinAssignExp - void visit(ASTBase.AddAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.MinAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.MulAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.DivAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.ModAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.PowAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.AndAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.OrAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.XorAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.ShlAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.ShrAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.UshrAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - void visit(ASTBase.CatAssignExp e) { visit(cast(ASTBase.BinAssignExp)e); } - - //=============================================================================== - // TemplateParameter - void visit(ASTBase.TemplateAliasParameter tp) { visit(cast(ASTBase.TemplateParameter)tp); } - void visit(ASTBase.TemplateTypeParameter tp) { visit(cast(ASTBase.TemplateParameter)tp); } - void visit(ASTBase.TemplateTupleParameter tp) { visit(cast(ASTBase.TemplateParameter)tp); } - void visit(ASTBase.TemplateValueParameter tp) { visit(cast(ASTBase.TemplateParameter)tp); } - - void visit(ASTBase.TemplateThisParameter tp) { visit(cast(ASTBase.TemplateTypeParameter)tp); } - - //=============================================================================== - // Condition - void visit(ASTBase.StaticIfCondition c) { visit(cast(ASTBase.Condition)c); } - void visit(ASTBase.DVCondition c) { visit(cast(ASTBase.Condition)c); } - void visit(ASTBase.DebugCondition c) { visit(cast(ASTBase.DVCondition)c); } - void visit(ASTBase.VersionCondition c) { visit(cast(ASTBase.DVCondition)c); } - - //=============================================================================== - // Initializer - void visit(ASTBase.ExpInitializer i) { visit(cast(ASTBase.Initializer)i); } - void visit(ASTBase.StructInitializer i) { visit(cast(ASTBase.Initializer)i); } - void visit(ASTBase.ArrayInitializer i) { visit(cast(ASTBase.Initializer)i); } - void visit(ASTBase.VoidInitializer i) { visit(cast(ASTBase.Initializer)i); } -} diff --git a/src/ddmd/astcodegen.d b/src/ddmd/astcodegen.d index f78aef9515bd..0ca6c3af652a 100644 --- a/src/ddmd/astcodegen.d +++ b/src/ddmd/astcodegen.d @@ -28,6 +28,7 @@ struct ASTCodegen import ddmd.statement; import ddmd.staticassert; import ddmd.typesem; + import ddmd.ctfeexpr; alias initializerToExpression = ddmd.initsem.initializerToExpression; alias typeToExpression = ddmd.typesem.typeToExpression; diff --git a/src/ddmd/asttypename.d b/src/ddmd/asttypename.d index d9201fc6d1d2..41b0b37bc19e 100644 --- a/src/ddmd/asttypename.d +++ b/src/ddmd/asttypename.d @@ -102,7 +102,7 @@ string astTypeName(` ~ P[0].stringof ~ ` node) return astTypeNameFunctions ~ ` private extern(C++) final class AstTypeNameVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public : string typeName; ` ~ visitOverloads ~ "}"; diff --git a/src/ddmd/blockexit.d b/src/ddmd/blockexit.d index e93eb7c879c3..d284e825ea9d 100644 --- a/src/ddmd/blockexit.d +++ b/src/ddmd/blockexit.d @@ -64,7 +64,7 @@ int blockExit(Statement s, FuncDeclaration func, bool mustNotThrow) { extern (C++) final class BlockExit : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: FuncDeclaration func; bool mustNotThrow; diff --git a/src/ddmd/canthrow.d b/src/ddmd/canthrow.d index 5e31695bb57a..8a1c5720677c 100644 --- a/src/ddmd/canthrow.d +++ b/src/ddmd/canthrow.d @@ -39,7 +39,7 @@ extern (C++) bool canThrow(Expression e, FuncDeclaration func, bool mustNotThrow // stop walking if we determine this expression can throw extern (C++) final class CanThrow : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; FuncDeclaration func; bool mustNotThrow; diff --git a/src/ddmd/cppmangle.d b/src/ddmd/cppmangle.d index 3212860b1a85..dda23c450ccf 100644 --- a/src/ddmd/cppmangle.d +++ b/src/ddmd/cppmangle.d @@ -76,7 +76,7 @@ const(char)* cppTypeInfoMangleItanium(Dsymbol s) private final class CppMangleVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Objects components; // array of components available for substitution OutBuffer* buf; // append the mangling to buf[] Loc loc; // location for use in error messages diff --git a/src/ddmd/cppmanglewin.d b/src/ddmd/cppmanglewin.d index eb2b857119aa..85359b878fc5 100644 --- a/src/ddmd/cppmanglewin.d +++ b/src/ddmd/cppmanglewin.d @@ -54,7 +54,7 @@ private final class VisualCPPMangler : Visitor enum VC_SAVED_TYPE_CNT = 10u; enum VC_SAVED_IDENT_CNT = 10u; - alias visit = super.visit; + alias visit = Visitor.visit; const(char)*[VC_SAVED_IDENT_CNT] saved_idents; Type[VC_SAVED_TYPE_CNT] saved_types; diff --git a/src/ddmd/dcast.d b/src/ddmd/dcast.d index 64723164a3e3..ef5aa70e4ef7 100644 --- a/src/ddmd/dcast.d +++ b/src/ddmd/dcast.d @@ -52,7 +52,7 @@ extern (C++) Expression implicitCastTo(Expression e, Scope* sc, Type t) { extern (C++) final class ImplicitCastTo : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Type t; Scope* sc; @@ -180,7 +180,7 @@ extern (C++) MATCH implicitConvTo(Expression e, Type t) { extern (C++) final class ImplicitConvTo : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Type t; MATCH result; @@ -1428,7 +1428,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t) { extern (C++) final class CastTo : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Type t; Scope* sc; @@ -2487,7 +2487,7 @@ extern (C++) Expression inferType(Expression e, Type t, int flag = 0) { extern (C++) final class InferType : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Type t; int flag; @@ -3494,7 +3494,7 @@ extern (C++) IntRange getIntRange(Expression e) { extern (C++) final class IntRangeVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: IntRange range; diff --git a/src/ddmd/delegatize.d b/src/ddmd/delegatize.d index 1e34cca096d3..2a464795fc47 100644 --- a/src/ddmd/delegatize.d +++ b/src/ddmd/delegatize.d @@ -88,7 +88,7 @@ private void lambdaSetParent(Expression e, FuncDeclaration fd) { extern (C++) final class LambdaSetParent : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; FuncDeclaration fd; public: @@ -143,7 +143,7 @@ extern (C++) bool lambdaCheckForNestedRef(Expression e, Scope* sc) { extern (C++) final class LambdaCheckForNestedRef : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: Scope* sc; bool result; diff --git a/src/ddmd/dinterpret.d b/src/ddmd/dinterpret.d index 8be5a27f1a7d..b6bd4160ded5 100644 --- a/src/ddmd/dinterpret.d +++ b/src/ddmd/dinterpret.d @@ -262,7 +262,7 @@ struct CompiledCtfeFunction { extern (C++) final class VarWalker : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: CompiledCtfeFunction* ccf; @@ -342,7 +342,7 @@ struct CompiledCtfeFunction private extern (C++) final class CtfeCompiler : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: CompiledCtfeFunction* ccf; @@ -1055,7 +1055,7 @@ private Expression interpret(FuncDeclaration fd, InterState* istate, Expressions private extern (C++) final class Interpreter : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: InterState* istate; CtfeGoal goal; diff --git a/src/ddmd/dmangle.d b/src/ddmd/dmangle.d index eca78b119220..a3e02dc01e31 100644 --- a/src/ddmd/dmangle.d +++ b/src/ddmd/dmangle.d @@ -167,7 +167,7 @@ private void MODtoDecoBuffer(OutBuffer* buf, MOD mod) private extern (C++) final class Mangler : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: static assert(Key.sizeof == size_t.sizeof); AA* types; diff --git a/src/ddmd/doc.d b/src/ddmd/doc.d index 191cea70ed83..8bf873545565 100644 --- a/src/ddmd/doc.d +++ b/src/ddmd/doc.d @@ -821,7 +821,7 @@ extern (C++) void emitComment(Dsymbol s, OutBuffer* buf, Scope* sc) { extern (C++) final class EmitComment : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: OutBuffer* buf; Scope* sc; @@ -1097,7 +1097,7 @@ extern (C++) void toDocBuffer(Dsymbol s, OutBuffer* buf, Scope* sc) { extern (C++) final class ToDocBuffer : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: OutBuffer* buf; Scope* sc; diff --git a/src/ddmd/dstruct.d b/src/ddmd/dstruct.d index d670275551d5..10441264888d 100644 --- a/src/ddmd/dstruct.d +++ b/src/ddmd/dstruct.d @@ -71,7 +71,7 @@ extern (C++) void semanticTypeInfo(Scope* sc, Type t) { extern (C++) final class FullTypeInfoVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Scope* sc; diff --git a/src/ddmd/dsymbolsem.d b/src/ddmd/dsymbolsem.d index 3fb0e946385a..de1a2bf493b6 100644 --- a/src/ddmd/dsymbolsem.d +++ b/src/ddmd/dsymbolsem.d @@ -109,7 +109,7 @@ extern(C++) void dsymbolSemantic(Dsymbol dsym, Scope* sc) extern(C++) final class Semantic2Visitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Scope* sc; this(Scope* sc) { @@ -571,7 +571,7 @@ const(char)* getMessage(DeprecatedDeclaration dd) extern(C++) final class Semantic3Visitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Scope* sc; this(Scope* sc) @@ -1785,7 +1785,7 @@ extern(C++) final class Semantic3Visitor : Visitor private extern(C++) final class DsymbolSemanticVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Scope* sc; this(Scope* sc) diff --git a/src/ddmd/dtemplate.d b/src/ddmd/dtemplate.d index e27fe65869f9..b75161ae2867 100644 --- a/src/ddmd/dtemplate.d +++ b/src/ddmd/dtemplate.d @@ -3171,7 +3171,7 @@ MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplateParameters* param { extern (C++) final class DeduceType : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Scope* sc; Type tparam; @@ -4607,7 +4607,7 @@ bool reliesOnTident(Type t, TemplateParameters* tparams = null, size_t iStart = { extern (C++) final class ReliesOnTident : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: TemplateParameters* tparams; size_t iStart; diff --git a/src/ddmd/e2ir.d b/src/ddmd/e2ir.d index 7b3697110ef0..2f926d474132 100644 --- a/src/ddmd/e2ir.d +++ b/src/ddmd/e2ir.d @@ -1054,7 +1054,7 @@ elem *toElem(Expression e, IRState *irs) result = null; } - alias visit = super.visit; + alias visit = Visitor.visit; /*************************************** */ diff --git a/src/ddmd/escape.d b/src/ddmd/escape.d index 052033cf898d..663d5f219acf 100644 --- a/src/ddmd/escape.d +++ b/src/ddmd/escape.d @@ -795,7 +795,7 @@ private void escapeByValue(Expression e, EscapeByResults* er) //printf("[%s] escapeByValue, e: %s\n", e.loc.toChars(), e.toChars()); extern (C++) final class EscapeVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: EscapeByResults* er; @@ -1079,7 +1079,7 @@ private void escapeByRef(Expression e, EscapeByResults* er) //printf("[%s] escapeByRef, e: %s\n", e.loc.toChars(), e.toChars()); extern (C++) final class EscapeRefVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: EscapeByResults* er; diff --git a/src/ddmd/expression.d b/src/ddmd/expression.d index f5d96ef58b43..d9e0b9dd0286 100644 --- a/src/ddmd/expression.d +++ b/src/ddmd/expression.d @@ -6946,7 +6946,7 @@ extern (C++) final class CondExp : BinExp { extern (C++) final class DtorVisitor : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: Scope* sc; CondExp ce; diff --git a/src/ddmd/expressionsem.d b/src/ddmd/expressionsem.d index 966807f8b2bb..43d54c40a40d 100644 --- a/src/ddmd/expressionsem.d +++ b/src/ddmd/expressionsem.d @@ -1164,7 +1164,7 @@ private Module loadStdMath() private extern (C++) final class ExpressionSemanticVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Scope* sc; Expression result; diff --git a/src/ddmd/hdrgen.d b/src/ddmd/hdrgen.d index 9e1866ff34c7..40c9210d2ac3 100644 --- a/src/ddmd/hdrgen.d +++ b/src/ddmd/hdrgen.d @@ -83,7 +83,7 @@ extern (C++) void genhdrfile(Module m) extern (C++) final class PrettyPrintVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: OutBuffer* buf; HdrGenState* hgs; diff --git a/src/ddmd/initsem.d b/src/ddmd/initsem.d index ad7496606a06..3f212882b4ff 100644 --- a/src/ddmd/initsem.d +++ b/src/ddmd/initsem.d @@ -91,7 +91,7 @@ extern(C++) Initializer initializerSemantic(Initializer init, Scope* sc, Type t, private extern(C++) final class InitializerSemanticVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Initializer result; Scope* sc; @@ -541,7 +541,7 @@ private extern(C++) final class InitializerSemanticVisitor : Visitor private extern(C++) final class InferTypeVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Initializer result; Scope* sc; @@ -705,7 +705,7 @@ private extern(C++) final class InferTypeVisitor : Visitor private extern(C++) final class InitToExpressionVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Expression result; Type itype; diff --git a/src/ddmd/inline.d b/src/ddmd/inline.d index ff30f124eaaf..67ec4ca3c695 100644 --- a/src/ddmd/inline.d +++ b/src/ddmd/inline.d @@ -84,7 +84,7 @@ final class InlineDoState private extern (C++) final class DoInlineAs(Result) : Visitor if (is(Result == Statement) || is(Result == Expression)) { - alias visit = super.visit; + alias visit = Visitor.visit; public: InlineDoState ids; Result result; @@ -804,7 +804,7 @@ Result doInlineAs(Result)(Expression e, InlineDoState ids) */ private extern (C++) final class InlineScanVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: FuncDeclaration parent; // function being scanned // As the visit method cannot return a value, these variables diff --git a/src/ddmd/inlinecost.d b/src/ddmd/inlinecost.d index 6c68e0a1023b..317a82017887 100644 --- a/src/ddmd/inlinecost.d +++ b/src/ddmd/inlinecost.d @@ -96,7 +96,7 @@ private: */ extern (C++) final class InlineCostVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: int nested; bool hasthis; @@ -285,7 +285,7 @@ public: { extern (C++) final class LambdaInlineCost : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; InlineCostVisitor icv; public: diff --git a/src/ddmd/json.d b/src/ddmd/json.d index d401e61edaf0..fb04d9b2249f 100644 --- a/src/ddmd/json.d +++ b/src/ddmd/json.d @@ -36,7 +36,7 @@ import ddmd.visitor; private extern (C++) final class ToJsonVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: OutBuffer* buf; int indentLevel; diff --git a/src/ddmd/nogc.d b/src/ddmd/nogc.d index 6e48fbe49d38..c8dfb14d18ca 100644 --- a/src/ddmd/nogc.d +++ b/src/ddmd/nogc.d @@ -29,7 +29,7 @@ import ddmd.visitor; */ extern (C++) final class NOGCVisitor : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: FuncDeclaration f; bool err; diff --git a/src/ddmd/opover.d b/src/ddmd/opover.d index cbb191b094b4..09b0267c5954 100644 --- a/src/ddmd/opover.d +++ b/src/ddmd/opover.d @@ -71,7 +71,7 @@ private Identifier opId(Expression e) { extern (C++) final class OpIdVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Identifier id; @@ -279,7 +279,7 @@ private Identifier opId_r(Expression e) { extern (C++) final class OpIdRVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Identifier id; @@ -450,7 +450,7 @@ extern (C++) Expression op_overload(Expression e, Scope* sc) { extern (C++) final class OpOverload : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Scope* sc; Expression result; diff --git a/src/ddmd/optimize.d b/src/ddmd/optimize.d index 5dc94175ab73..5bf5ee6e7e7d 100644 --- a/src/ddmd/optimize.d +++ b/src/ddmd/optimize.d @@ -193,7 +193,7 @@ extern (C++) Expression Expression_optimize(Expression e, int result, bool keepL { extern (C++) final class OptimizeVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: int result; bool keepLvalue; diff --git a/src/ddmd/parsetimevisitor.d b/src/ddmd/parsetimevisitor.d new file mode 100644 index 000000000000..07eb63536137 --- /dev/null +++ b/src/ddmd/parsetimevisitor.d @@ -0,0 +1,278 @@ +module ddmd.parsetimevisitor; + +// Online documentation: https://dlang.org/phobos/ddmd_parsetimevisitor.html + +/** Basic and dumm visitor which implements a visit method for each AST node + * implemented in AST. This visitor is the parent of strict, transitive + * and permissive visitors. + */ +extern(C++) class ParseTimeVisitor(AST) +{ + void visit(AST.Dsymbol) { assert(0); } + void visit(AST.Parameter) { assert(0); } + void visit(AST.Statement) { assert(0); } + void visit(AST.Type) { assert(0); } + void visit(AST.Expression) { assert(0); } + void visit(AST.TemplateParameter) { assert(0); } + void visit(AST.Condition) { assert(0); } +// void visit(AST.StaticForeach) { assert(0); } + void visit(AST.Initializer) { assert(0); } + + //======================================================================================= + // Dsymbols + void visit(AST.AliasThis s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.Declaration s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.ScopeDsymbol s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.Import s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.AttribDeclaration s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.StaticAssert s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.DebugSymbol s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.VersionSymbol s) { visit(cast(AST.Dsymbol)s); } + + // ScopeDsymbols + void visit(AST.Package s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.EnumDeclaration s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.AggregateDeclaration s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.TemplateDeclaration s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.TemplateInstance s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.Nspace s) { visit(cast(AST.ScopeDsymbol)s); } + + //========================================================================================= + // Declarations + void visit(AST.VarDeclaration s) { visit(cast(AST.Declaration)s); } + void visit(AST.FuncDeclaration s) { visit(cast(AST.Declaration)s); } + void visit(AST.AliasDeclaration s) { visit(cast(AST.Declaration)s); } + void visit(AST.TupleDeclaration s) { visit(cast(AST.Declaration)s); } + + // FuncDeclarations + void visit(AST.FuncLiteralDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.PostBlitDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.CtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.DtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.InvariantDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.UnitTestDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.NewDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.DeleteDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.StaticCtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.StaticDtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.SharedStaticCtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.SharedStaticDtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + + // AttribDeclarations + void visit(AST.CompileDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.UserAttributeDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.LinkDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.AnonDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.AlignDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.CPPMangleDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.ProtDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.PragmaDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.StorageClassDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.ConditionalDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + + //============================================================================================== + // Miscellaneous + void visit(AST.DeprecatedDeclaration s) { visit(cast(AST.StorageClassDeclaration)s); } + void visit(AST.StaticIfDeclaration s) { visit(cast(AST.ConditionalDeclaration)s); } + void visit(AST.StaticForeachDeclaration s) { visit(cast(AST.ConditionalDeclaration)s); } + void visit(AST.EnumMember s) { visit(cast(AST.VarDeclaration)s); } + void visit(AST.Module s) { visit(cast(AST.Package)s); } + void visit(AST.StructDeclaration s) { visit(cast(AST.AggregateDeclaration)s); } + void visit(AST.UnionDeclaration s) { visit(cast(AST.StructDeclaration)s); } + void visit(AST.ClassDeclaration s) { visit(cast(AST.AggregateDeclaration)s); } + void visit(AST.InterfaceDeclaration s) { visit(cast(AST.ClassDeclaration)s); } + void visit(AST.TemplateMixin s) { visit(cast(AST.TemplateInstance)s); } + + //============================================================================================ + // Statements + void visit(AST.ImportStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ScopeStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ReturnStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.LabelStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.StaticAssertStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.CompileStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.WhileStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ForStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.DoStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ForeachRangeStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ForeachStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.IfStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.OnScopeStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ConditionalStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.StaticForeachStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.PragmaStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.SwitchStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.CaseRangeStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.CaseStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.DefaultStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.BreakStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ContinueStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.GotoDefaultStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.GotoCaseStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.GotoStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.SynchronizedStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.WithStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.TryCatchStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.TryFinallyStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ThrowStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.AsmStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.ExpStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.CompoundStatement s) { visit(cast(AST.Statement)s); } + + // CompoundStatements + void visit(AST.CompoundDeclarationStatement s) { visit(cast(AST.CompoundStatement)s); } + void visit(AST.CompoundAsmStatement s) { visit(cast(AST.CompoundStatement)s); } + + //========================================================================================= + // Types + void visit(AST.TypeBasic t) { visit(cast(AST.Type)t); } + void visit(AST.TypeError t) { visit(cast(AST.Type)t); } + void visit(AST.TypeNull t) { visit(cast(AST.Type)t); } + void visit(AST.TypeVector t) { visit(cast(AST.Type)t); } + void visit(AST.TypeEnum t) { visit(cast(AST.Type)t); } + void visit(AST.TypeTuple t) { visit(cast(AST.Type)t); } + void visit(AST.TypeClass t) { visit(cast(AST.Type)t); } + void visit(AST.TypeStruct t) { visit(cast(AST.Type)t); } + void visit(AST.TypeNext t) { visit(cast(AST.Type)t); } + void visit(AST.TypeQualified t) { visit(cast(AST.Type)t); } + + // TypeNext + void visit(AST.TypeReference t) { visit(cast(AST.TypeNext)t); } + void visit(AST.TypeSlice t) { visit(cast(AST.TypeNext)t); } + void visit(AST.TypeDelegate t) { visit(cast(AST.TypeNext)t); } + void visit(AST.TypePointer t) { visit(cast(AST.TypeNext)t); } + void visit(AST.TypeFunction t) { visit(cast(AST.TypeNext)t); } + void visit(AST.TypeArray t) { visit(cast(AST.TypeNext)t); } + + // TypeArray + void visit(AST.TypeDArray t) { visit(cast(AST.TypeArray)t); } + void visit(AST.TypeAArray t) { visit(cast(AST.TypeArray)t); } + void visit(AST.TypeSArray t) { visit(cast(AST.TypeArray)t); } + + // TypeQualified + void visit(AST.TypeIdentifier t) { visit(cast(AST.TypeQualified)t); } + void visit(AST.TypeReturn t) { visit(cast(AST.TypeQualified)t); } + void visit(AST.TypeTypeof t) { visit(cast(AST.TypeQualified)t); } + void visit(AST.TypeInstance t) { visit(cast(AST.TypeQualified)t); } + + //================================================================================= + // Expressions + void visit(AST.DeclarationExp e) { visit(cast(AST.Expression)e); } + void visit(AST.IntegerExp e) { visit(cast(AST.Expression)e); } + void visit(AST.NewAnonClassExp e) { visit(cast(AST.Expression)e); } + void visit(AST.IsExp e) { visit(cast(AST.Expression)e); } + void visit(AST.RealExp e) { visit(cast(AST.Expression)e); } + void visit(AST.NullExp e) { visit(cast(AST.Expression)e); } + void visit(AST.TypeidExp e) { visit(cast(AST.Expression)e); } + void visit(AST.TraitsExp e) { visit(cast(AST.Expression)e); } + void visit(AST.StringExp e) { visit(cast(AST.Expression)e); } + void visit(AST.NewExp e) { visit(cast(AST.Expression)e); } + void visit(AST.AssocArrayLiteralExp e) { visit(cast(AST.Expression)e); } + void visit(AST.ArrayLiteralExp e) { visit(cast(AST.Expression)e); } + void visit(AST.FuncExp e) { visit(cast(AST.Expression)e); } + void visit(AST.IntervalExp e) { visit(cast(AST.Expression)e); } + void visit(AST.TypeExp e) { visit(cast(AST.Expression)e); } + void visit(AST.ScopeExp e) { visit(cast(AST.Expression)e); } + void visit(AST.IdentifierExp e) { visit(cast(AST.Expression)e); } + void visit(AST.UnaExp e) { visit(cast(AST.Expression)e); } + void visit(AST.DefaultInitExp e) { visit(cast(AST.Expression)e); } + void visit(AST.BinExp e) { visit(cast(AST.Expression)e); } + void visit(AST.DsymbolExp e) { visit(cast(AST.Expression)e); } + void visit(AST.TemplateExp e) { visit(cast(AST.Expression)e); } + void visit(AST.SymbolExp e) { visit(cast(AST.Expression)e); } + void visit(AST.TupleExp e) { visit(cast(AST.Expression)e); } + void visit(AST.ThisExp e) { visit(cast(AST.Expression)e); } + + // Miscellaneous + void visit(AST.VarExp e) { visit(cast(AST.SymbolExp)e); } + void visit(AST.DollarExp e) { visit(cast(AST.IdentifierExp)e); } + void visit(AST.SuperExp e) { visit(cast(AST.ThisExp)e); } + + // UnaExp + void visit(AST.AddrExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.PreExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.PtrExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.NegExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.UAddExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.NotExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.ComExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DeleteExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.CastExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.CallExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DotIdExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.AssertExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.CompileExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.ImportExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DotTemplateInstanceExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.ArrayExp e) { visit(cast(AST.UnaExp)e); } + + // DefaultInitExp + void visit(AST.FuncInitExp e) { visit(cast(AST.DefaultInitExp)e); } + void visit(AST.PrettyFuncInitExp e) { visit(cast(AST.DefaultInitExp)e); } + void visit(AST.FileInitExp e) { visit(cast(AST.DefaultInitExp)e); } + void visit(AST.LineInitExp e) { visit(cast(AST.DefaultInitExp)e); } + void visit(AST.ModuleInitExp e) { visit(cast(AST.DefaultInitExp)e); } + + // BinExp + void visit(AST.CommaExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.PostExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.PowExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.MulExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.DivExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.ModExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.AddExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.MinExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.CatExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.ShlExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.ShrExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.UshrExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.EqualExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.InExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.IdentityExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.CmpExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.AndExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.XorExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.OrExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.LogicalExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.CondExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.AssignExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.BinAssignExp e) { visit(cast(AST.BinExp)e); } + + // BinAssignExp + void visit(AST.AddAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.MinAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.MulAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.DivAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.ModAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.PowAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.AndAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.OrAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.XorAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.ShlAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.ShrAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.UshrAssignExp e) { visit(cast(AST.BinAssignExp)e); } + void visit(AST.CatAssignExp e) { visit(cast(AST.BinAssignExp)e); } + + //=============================================================================== + // TemplateParameter + void visit(AST.TemplateAliasParameter tp) { visit(cast(AST.TemplateParameter)tp); } + void visit(AST.TemplateTypeParameter tp) { visit(cast(AST.TemplateParameter)tp); } + void visit(AST.TemplateTupleParameter tp) { visit(cast(AST.TemplateParameter)tp); } + void visit(AST.TemplateValueParameter tp) { visit(cast(AST.TemplateParameter)tp); } + + void visit(AST.TemplateThisParameter tp) { visit(cast(AST.TemplateTypeParameter)tp); } + + //=============================================================================== + // Condition + void visit(AST.StaticIfCondition c) { visit(cast(AST.Condition)c); } + void visit(AST.DVCondition c) { visit(cast(AST.Condition)c); } + void visit(AST.DebugCondition c) { visit(cast(AST.DVCondition)c); } + void visit(AST.VersionCondition c) { visit(cast(AST.DVCondition)c); } + + //=============================================================================== + // Initializer + void visit(AST.ExpInitializer i) { visit(cast(AST.Initializer)i); } + void visit(AST.StructInitializer i) { visit(cast(AST.Initializer)i); } + void visit(AST.ArrayInitializer i) { visit(cast(AST.Initializer)i); } + void visit(AST.VoidInitializer i) { visit(cast(AST.Initializer)i); } +} diff --git a/src/ddmd/permissivevisitor.d b/src/ddmd/permissivevisitor.d index 7430a1b373ca..6e3b3dbbee6c 100644 --- a/src/ddmd/permissivevisitor.d +++ b/src/ddmd/permissivevisitor.d @@ -2,23 +2,22 @@ module ddmd.permissivevisitor; // Online documentation: https://dlang.org/phobos/ddmd_permissivevisitor.html -import ddmd.astbase; -import ddmd.astbasevisitor; +import ddmd.parsetimevisitor; /** PermissiveVisitor overrides all the visit methods in the parent class * that assert(0) in order to facilitate the traversal of subsets of the AST. * It does not implement any visiting logic. */ -class PermissiveVisitor: Visitor +extern(C++) class PermissiveVisitor(AST): ParseTimeVisitor!AST { - alias visit = super.visit; + alias visit = ParseTimeVisitor!AST.visit; - override void visit(ASTBase.Dsymbol){} - override void visit(ASTBase.Parameter){} - override void visit(ASTBase.Statement){} - override void visit(ASTBase.Type){} - override void visit(ASTBase.Expression){} - override void visit(ASTBase.TemplateParameter){} - override void visit(ASTBase.Condition){} - override void visit(ASTBase.Initializer){} + override void visit(AST.Dsymbol){} + override void visit(AST.Parameter){} + override void visit(AST.Statement){} + override void visit(AST.Type){} + override void visit(AST.Expression){} + override void visit(AST.TemplateParameter){} + override void visit(AST.Condition){} + override void visit(AST.Initializer){} } diff --git a/src/ddmd/printast.d b/src/ddmd/printast.d index c155d170bc3c..10c98cb3196a 100644 --- a/src/ddmd/printast.d +++ b/src/ddmd/printast.d @@ -34,7 +34,7 @@ private: extern (C++) final class PrintASTVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; int indent; diff --git a/src/ddmd/s2ir.d b/src/ddmd/s2ir.d index 88a5194df9b4..8cc9b26c80f0 100644 --- a/src/ddmd/s2ir.d +++ b/src/ddmd/s2ir.d @@ -173,7 +173,7 @@ private extern (C++) class S2irVisitor : Visitor this.irs = irs; } - alias visit = super.visit; + alias visit = Visitor.visit; /**************************************** * This should be overridden by each statement class. diff --git a/src/ddmd/sapply.d b/src/ddmd/sapply.d index 278c1e7b574a..1c3c49c9c65e 100644 --- a/src/ddmd/sapply.d +++ b/src/ddmd/sapply.d @@ -27,7 +27,7 @@ import ddmd.visitor; */ extern (C++) final class PostorderStatementVisitor : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: StoppableVisitor v; diff --git a/src/ddmd/sideeffect.d b/src/ddmd/sideeffect.d index ded78e5cccdf..4c79589f95a8 100644 --- a/src/ddmd/sideeffect.d +++ b/src/ddmd/sideeffect.d @@ -36,7 +36,7 @@ extern (C++) bool isTrivialExp(Expression e) { extern (C++) final class IsTrivialExp : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: extern (D) this() { @@ -69,7 +69,7 @@ extern (C++) bool hasSideEffect(Expression e) { extern (C++) final class LambdaHasSideEffect : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: extern (D) this() { diff --git a/src/ddmd/statement.d b/src/ddmd/statement.d index a8fa89b52727..84ca04f98538 100644 --- a/src/ddmd/statement.d +++ b/src/ddmd/statement.d @@ -160,7 +160,7 @@ extern (C++) abstract class Statement : RootObject { extern (C++) final class UsesEH : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: override void visit(Statement s) { @@ -199,7 +199,7 @@ extern (C++) abstract class Statement : RootObject { extern (C++) final class ComeFrom : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: override void visit(Statement s) { @@ -238,7 +238,7 @@ extern (C++) abstract class Statement : RootObject { extern (C++) final class HasCode : StoppableVisitor { - alias visit = super.visit; + alias visit = StoppableVisitor.visit; public: override void visit(Statement s) { @@ -467,7 +467,7 @@ extern (C++) Statement toStatement(Dsymbol s) { extern (C++) final class ToStmt : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: Statement result; diff --git a/src/ddmd/statement_rewrite_walker.d b/src/ddmd/statement_rewrite_walker.d index f0d328fdef08..57cca171e12d 100644 --- a/src/ddmd/statement_rewrite_walker.d +++ b/src/ddmd/statement_rewrite_walker.d @@ -22,7 +22,7 @@ import ddmd.visitor; */ extern (C++) class StatementRewriteWalker : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; /* Point the currently visited statement. * By using replaceCurrent() method, you can replace AST during walking. diff --git a/src/ddmd/statementsem.d b/src/ddmd/statementsem.d index 1a8e20e033af..09e2eeca174b 100644 --- a/src/ddmd/statementsem.d +++ b/src/ddmd/statementsem.d @@ -131,7 +131,7 @@ extern(C++) Statement statementSemantic(Statement s, Scope* sc) private extern (C++) final class StatementSemanticVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Statement result; Scope* sc; diff --git a/src/ddmd/strictvisitor.d b/src/ddmd/strictvisitor.d index 835a405aba44..46c557c4817f 100644 --- a/src/ddmd/strictvisitor.d +++ b/src/ddmd/strictvisitor.d @@ -2,226 +2,225 @@ module ddmd.strictvisitor; // Online documentation: https://dlang.org/phobos/ddmd_strictvisitor.html -import ddmd.astbase; -import ddmd.astbasevisitor; +import ddmd.parsetimevisitor; /** The StrictVisitor asserts 0 an all visiting functions in order to * make sure that all the nodes are visited. */ -class StrictVisitor : Visitor +extern(C++) class StrictVisitor(AST) : ParseTimeVisitor!AST { - alias visit = super.visit; + alias visit = ParseTimeVisitor!AST.visit; - override void visit(ASTBase.Dsymbol) { assert(0); } - override void visit(ASTBase.AliasThis) { assert(0); } - override void visit(ASTBase.Declaration) { assert(0); } - override void visit(ASTBase.ScopeDsymbol) { assert(0); } - override void visit(ASTBase.Import) { assert(0); } - override void visit(ASTBase.AttribDeclaration) { assert(0); } - override void visit(ASTBase.StaticAssert) { assert(0); } - override void visit(ASTBase.DebugSymbol) { assert(0); } - override void visit(ASTBase.VersionSymbol) { assert(0); } - override void visit(ASTBase.VarDeclaration) { assert(0); } - override void visit(ASTBase.FuncDeclaration) { assert(0); } - override void visit(ASTBase.AliasDeclaration) { assert(0); } - override void visit(ASTBase.TupleDeclaration) { assert(0); } - override void visit(ASTBase.FuncLiteralDeclaration) { assert(0); } - override void visit(ASTBase.PostBlitDeclaration) { assert(0); } - override void visit(ASTBase.CtorDeclaration) { assert(0); } - override void visit(ASTBase.DtorDeclaration) { assert(0); } - override void visit(ASTBase.InvariantDeclaration) { assert(0); } - override void visit(ASTBase.UnitTestDeclaration) { assert(0); } - override void visit(ASTBase.NewDeclaration) { assert(0); } - override void visit(ASTBase.DeleteDeclaration) { assert(0); } - override void visit(ASTBase.StaticCtorDeclaration) { assert(0); } - override void visit(ASTBase.StaticDtorDeclaration) { assert(0); } - override void visit(ASTBase.SharedStaticCtorDeclaration) { assert(0); } - override void visit(ASTBase.SharedStaticDtorDeclaration) { assert(0); } - override void visit(ASTBase.Package) { assert(0); } - override void visit(ASTBase.EnumDeclaration) { assert(0); } - override void visit(ASTBase.AggregateDeclaration) { assert(0); } - override void visit(ASTBase.TemplateDeclaration) { assert(0); } - override void visit(ASTBase.TemplateInstance) { assert(0); } - override void visit(ASTBase.Nspace) { assert(0); } - override void visit(ASTBase.CompileDeclaration) { assert(0); } - override void visit(ASTBase.UserAttributeDeclaration) { assert(0); } - override void visit(ASTBase.LinkDeclaration) { assert(0); } - override void visit(ASTBase.AnonDeclaration) { assert(0); } - override void visit(ASTBase.AlignDeclaration) { assert(0); } - override void visit(ASTBase.CPPMangleDeclaration) { assert(0); } - override void visit(ASTBase.ProtDeclaration) { assert(0); } - override void visit(ASTBase.PragmaDeclaration) { assert(0); } - override void visit(ASTBase.StorageClassDeclaration) { assert(0); } - override void visit(ASTBase.ConditionalDeclaration) { assert(0); } - override void visit(ASTBase.DeprecatedDeclaration) { assert(0); } - override void visit(ASTBase.StaticIfDeclaration) { assert(0); } - override void visit(ASTBase.EnumMember) { assert(0); } - override void visit(ASTBase.Module) { assert(0); } - override void visit(ASTBase.StructDeclaration) { assert(0); } - override void visit(ASTBase.UnionDeclaration) { assert(0); } - override void visit(ASTBase.ClassDeclaration) { assert(0); } - override void visit(ASTBase.InterfaceDeclaration) { assert(0); } - override void visit(ASTBase.TemplateMixin) { assert(0); } - override void visit(ASTBase.Parameter) { assert(0); } - override void visit(ASTBase.Statement) { assert(0); } - override void visit(ASTBase.ImportStatement) { assert(0); } - override void visit(ASTBase.ScopeStatement) { assert(0); } - override void visit(ASTBase.ReturnStatement) { assert(0); } - override void visit(ASTBase.LabelStatement) { assert(0); } - override void visit(ASTBase.StaticAssertStatement) { assert(0); } - override void visit(ASTBase.CompileStatement) { assert(0); } - override void visit(ASTBase.WhileStatement) { assert(0); } - override void visit(ASTBase.ForStatement) { assert(0); } - override void visit(ASTBase.DoStatement) { assert(0); } - override void visit(ASTBase.ForeachRangeStatement) { assert(0); } - override void visit(ASTBase.ForeachStatement) { assert(0); } - override void visit(ASTBase.IfStatement) { assert(0); } - override void visit(ASTBase.OnScopeStatement) { assert(0); } - override void visit(ASTBase.ConditionalStatement) { assert(0); } - override void visit(ASTBase.PragmaStatement) { assert(0); } - override void visit(ASTBase.SwitchStatement) { assert(0); } - override void visit(ASTBase.CaseRangeStatement) { assert(0); } - override void visit(ASTBase.CaseStatement) { assert(0); } - override void visit(ASTBase.DefaultStatement) { assert(0); } - override void visit(ASTBase.BreakStatement) { assert(0); } - override void visit(ASTBase.ContinueStatement) { assert(0); } - override void visit(ASTBase.GotoDefaultStatement) { assert(0); } - override void visit(ASTBase.GotoCaseStatement) { assert(0); } - override void visit(ASTBase.GotoStatement) { assert(0); } - override void visit(ASTBase.SynchronizedStatement) { assert(0); } - override void visit(ASTBase.WithStatement) { assert(0); } - override void visit(ASTBase.TryCatchStatement) { assert(0); } - override void visit(ASTBase.TryFinallyStatement) { assert(0); } - override void visit(ASTBase.ThrowStatement) { assert(0); } - override void visit(ASTBase.AsmStatement) { assert(0); } - override void visit(ASTBase.ExpStatement) { assert(0); } - override void visit(ASTBase.CompoundStatement) { assert(0); } - override void visit(ASTBase.CompoundDeclarationStatement) { assert(0); } - override void visit(ASTBase.CompoundAsmStatement) { assert(0); } - override void visit(ASTBase.Type) { assert(0); } - override void visit(ASTBase.TypeBasic) { assert(0); } - override void visit(ASTBase.TypeError) { assert(0); } - override void visit(ASTBase.TypeNull) { assert(0); } - override void visit(ASTBase.TypeVector) { assert(0); } - override void visit(ASTBase.TypeEnum) { assert(0); } - override void visit(ASTBase.TypeTuple) { assert(0); } - override void visit(ASTBase.TypeClass) { assert(0); } - override void visit(ASTBase.TypeStruct) { assert(0); } - override void visit(ASTBase.TypeNext) { assert(0); } - override void visit(ASTBase.TypeReference) { assert(0); } - override void visit(ASTBase.TypeSlice) { assert(0); } - override void visit(ASTBase.TypeDelegate) { assert(0); } - override void visit(ASTBase.TypePointer) { assert(0); } - override void visit(ASTBase.TypeFunction) { assert(0); } - override void visit(ASTBase.TypeArray) { assert(0); } - override void visit(ASTBase.TypeDArray) { assert(0); } - override void visit(ASTBase.TypeAArray) { assert(0); } - override void visit(ASTBase.TypeSArray) { assert(0); } - override void visit(ASTBase.TypeQualified) { assert(0); } - override void visit(ASTBase.TypeIdentifier) { assert(0); } - override void visit(ASTBase.TypeReturn) { assert(0); } - override void visit(ASTBase.TypeTypeof) { assert(0); } - override void visit(ASTBase.TypeInstance) { assert(0); } - override void visit(ASTBase.Expression) { assert(0); } - override void visit(ASTBase.DeclarationExp) { assert(0); } - override void visit(ASTBase.IntegerExp) { assert(0); } - override void visit(ASTBase.NewAnonClassExp) { assert(0); } - override void visit(ASTBase.IsExp) { assert(0); } - override void visit(ASTBase.RealExp) { assert(0); } - override void visit(ASTBase.NullExp) { assert(0); } - override void visit(ASTBase.TypeidExp) { assert(0); } - override void visit(ASTBase.TraitsExp) { assert(0); } - override void visit(ASTBase.StringExp) { assert(0); } - override void visit(ASTBase.NewExp) { assert(0); } - override void visit(ASTBase.AssocArrayLiteralExp) { assert(0); } - override void visit(ASTBase.ArrayLiteralExp) { assert(0); } - override void visit(ASTBase.FuncExp) { assert(0); } - override void visit(ASTBase.IntervalExp) { assert(0); } - override void visit(ASTBase.TypeExp) { assert(0); } - override void visit(ASTBase.ScopeExp) { assert(0); } - override void visit(ASTBase.IdentifierExp) { assert(0); } - override void visit(ASTBase.UnaExp) { assert(0); } - override void visit(ASTBase.DefaultInitExp) { assert(0); } - override void visit(ASTBase.BinExp) { assert(0); } - override void visit(ASTBase.DsymbolExp) { assert(0); } - override void visit(ASTBase.TemplateExp) { assert(0); } - override void visit(ASTBase.SymbolExp) { assert(0); } - override void visit(ASTBase.VarExp) { assert(0); } - override void visit(ASTBase.TupleExp) { assert(0); } - override void visit(ASTBase.DollarExp) { assert(0); } - override void visit(ASTBase.ThisExp) { assert(0); } - override void visit(ASTBase.SuperExp) { assert(0); } - override void visit(ASTBase.AddrExp) { assert(0); } - override void visit(ASTBase.PreExp) { assert(0); } - override void visit(ASTBase.PtrExp) { assert(0); } - override void visit(ASTBase.NegExp) { assert(0); } - override void visit(ASTBase.UAddExp) { assert(0); } - override void visit(ASTBase.NotExp) { assert(0); } - override void visit(ASTBase.ComExp) { assert(0); } - override void visit(ASTBase.DeleteExp) { assert(0); } - override void visit(ASTBase.CastExp) { assert(0); } - override void visit(ASTBase.CallExp) { assert(0); } - override void visit(ASTBase.DotIdExp) { assert(0); } - override void visit(ASTBase.AssertExp) { assert(0); } - override void visit(ASTBase.CompileExp) { assert(0); } - override void visit(ASTBase.ImportExp) { assert(0); } - override void visit(ASTBase.DotTemplateInstanceExp) { assert(0); } - override void visit(ASTBase.ArrayExp) { assert(0); } - override void visit(ASTBase.FuncInitExp) { assert(0); } - override void visit(ASTBase.PrettyFuncInitExp) { assert(0); } - override void visit(ASTBase.FileInitExp) { assert(0); } - override void visit(ASTBase.LineInitExp) { assert(0); } - override void visit(ASTBase.ModuleInitExp) { assert(0); } - override void visit(ASTBase.CommaExp) { assert(0); } - override void visit(ASTBase.PostExp) { assert(0); } - override void visit(ASTBase.PowExp) { assert(0); } - override void visit(ASTBase.MulExp) { assert(0); } - override void visit(ASTBase.DivExp) { assert(0); } - override void visit(ASTBase.ModExp) { assert(0); } - override void visit(ASTBase.AddExp) { assert(0); } - override void visit(ASTBase.MinExp) { assert(0); } - override void visit(ASTBase.CatExp) { assert(0); } - override void visit(ASTBase.ShlExp) { assert(0); } - override void visit(ASTBase.ShrExp) { assert(0); } - override void visit(ASTBase.UshrExp) { assert(0); } - override void visit(ASTBase.EqualExp) { assert(0); } - override void visit(ASTBase.InExp) { assert(0); } - override void visit(ASTBase.IdentityExp) { assert(0); } - override void visit(ASTBase.CmpExp) { assert(0); } - override void visit(ASTBase.AndExp) { assert(0); } - override void visit(ASTBase.XorExp) { assert(0); } - override void visit(ASTBase.OrExp) { assert(0); } - override void visit(ASTBase.LogicalExp) { assert(0); } - override void visit(ASTBase.CondExp) { assert(0); } - override void visit(ASTBase.AssignExp) { assert(0); } - override void visit(ASTBase.BinAssignExp) { assert(0); } - override void visit(ASTBase.AddAssignExp) { assert(0); } - override void visit(ASTBase.MinAssignExp) { assert(0); } - override void visit(ASTBase.MulAssignExp) { assert(0); } - override void visit(ASTBase.DivAssignExp) { assert(0); } - override void visit(ASTBase.ModAssignExp) { assert(0); } - override void visit(ASTBase.PowAssignExp) { assert(0); } - override void visit(ASTBase.AndAssignExp) { assert(0); } - override void visit(ASTBase.OrAssignExp) { assert(0); } - override void visit(ASTBase.XorAssignExp) { assert(0); } - override void visit(ASTBase.ShlAssignExp) { assert(0); } - override void visit(ASTBase.ShrAssignExp) { assert(0); } - override void visit(ASTBase.UshrAssignExp) { assert(0); } - override void visit(ASTBase.CatAssignExp) { assert(0); } - override void visit(ASTBase.TemplateParameter) { assert(0); } - override void visit(ASTBase.TemplateAliasParameter) { assert(0); } - override void visit(ASTBase.TemplateTypeParameter) { assert(0); } - override void visit(ASTBase.TemplateTupleParameter) { assert(0); } - override void visit(ASTBase.TemplateValueParameter) { assert(0); } - override void visit(ASTBase.TemplateThisParameter) { assert(0); } - override void visit(ASTBase.Condition) { assert(0); } - override void visit(ASTBase.StaticIfCondition) { assert(0); } - override void visit(ASTBase.DVCondition) { assert(0); } - override void visit(ASTBase.DebugCondition) { assert(0); } - override void visit(ASTBase.VersionCondition) { assert(0); } - override void visit(ASTBase.Initializer) { assert(0); } - override void visit(ASTBase.ExpInitializer) { assert(0); } - override void visit(ASTBase.StructInitializer) { assert(0); } - override void visit(ASTBase.ArrayInitializer) { assert(0); } - override void visit(ASTBase.VoidInitializer) { assert(0); } + override void visit(AST.Dsymbol) { assert(0); } + override void visit(AST.AliasThis) { assert(0); } + override void visit(AST.Declaration) { assert(0); } + override void visit(AST.ScopeDsymbol) { assert(0); } + override void visit(AST.Import) { assert(0); } + override void visit(AST.AttribDeclaration) { assert(0); } + override void visit(AST.StaticAssert) { assert(0); } + override void visit(AST.DebugSymbol) { assert(0); } + override void visit(AST.VersionSymbol) { assert(0); } + override void visit(AST.VarDeclaration) { assert(0); } + override void visit(AST.FuncDeclaration) { assert(0); } + override void visit(AST.AliasDeclaration) { assert(0); } + override void visit(AST.TupleDeclaration) { assert(0); } + override void visit(AST.FuncLiteralDeclaration) { assert(0); } + override void visit(AST.PostBlitDeclaration) { assert(0); } + override void visit(AST.CtorDeclaration) { assert(0); } + override void visit(AST.DtorDeclaration) { assert(0); } + override void visit(AST.InvariantDeclaration) { assert(0); } + override void visit(AST.UnitTestDeclaration) { assert(0); } + override void visit(AST.NewDeclaration) { assert(0); } + override void visit(AST.DeleteDeclaration) { assert(0); } + override void visit(AST.StaticCtorDeclaration) { assert(0); } + override void visit(AST.StaticDtorDeclaration) { assert(0); } + override void visit(AST.SharedStaticCtorDeclaration) { assert(0); } + override void visit(AST.SharedStaticDtorDeclaration) { assert(0); } + override void visit(AST.Package) { assert(0); } + override void visit(AST.EnumDeclaration) { assert(0); } + override void visit(AST.AggregateDeclaration) { assert(0); } + override void visit(AST.TemplateDeclaration) { assert(0); } + override void visit(AST.TemplateInstance) { assert(0); } + override void visit(AST.Nspace) { assert(0); } + override void visit(AST.CompileDeclaration) { assert(0); } + override void visit(AST.UserAttributeDeclaration) { assert(0); } + override void visit(AST.LinkDeclaration) { assert(0); } + override void visit(AST.AnonDeclaration) { assert(0); } + override void visit(AST.AlignDeclaration) { assert(0); } + override void visit(AST.CPPMangleDeclaration) { assert(0); } + override void visit(AST.ProtDeclaration) { assert(0); } + override void visit(AST.PragmaDeclaration) { assert(0); } + override void visit(AST.StorageClassDeclaration) { assert(0); } + override void visit(AST.ConditionalDeclaration) { assert(0); } + override void visit(AST.DeprecatedDeclaration) { assert(0); } + override void visit(AST.StaticIfDeclaration) { assert(0); } + override void visit(AST.EnumMember) { assert(0); } + override void visit(AST.Module) { assert(0); } + override void visit(AST.StructDeclaration) { assert(0); } + override void visit(AST.UnionDeclaration) { assert(0); } + override void visit(AST.ClassDeclaration) { assert(0); } + override void visit(AST.InterfaceDeclaration) { assert(0); } + override void visit(AST.TemplateMixin) { assert(0); } + override void visit(AST.Parameter) { assert(0); } + override void visit(AST.Statement) { assert(0); } + override void visit(AST.ImportStatement) { assert(0); } + override void visit(AST.ScopeStatement) { assert(0); } + override void visit(AST.ReturnStatement) { assert(0); } + override void visit(AST.LabelStatement) { assert(0); } + override void visit(AST.StaticAssertStatement) { assert(0); } + override void visit(AST.CompileStatement) { assert(0); } + override void visit(AST.WhileStatement) { assert(0); } + override void visit(AST.ForStatement) { assert(0); } + override void visit(AST.DoStatement) { assert(0); } + override void visit(AST.ForeachRangeStatement) { assert(0); } + override void visit(AST.ForeachStatement) { assert(0); } + override void visit(AST.IfStatement) { assert(0); } + override void visit(AST.OnScopeStatement) { assert(0); } + override void visit(AST.ConditionalStatement) { assert(0); } + override void visit(AST.PragmaStatement) { assert(0); } + override void visit(AST.SwitchStatement) { assert(0); } + override void visit(AST.CaseRangeStatement) { assert(0); } + override void visit(AST.CaseStatement) { assert(0); } + override void visit(AST.DefaultStatement) { assert(0); } + override void visit(AST.BreakStatement) { assert(0); } + override void visit(AST.ContinueStatement) { assert(0); } + override void visit(AST.GotoDefaultStatement) { assert(0); } + override void visit(AST.GotoCaseStatement) { assert(0); } + override void visit(AST.GotoStatement) { assert(0); } + override void visit(AST.SynchronizedStatement) { assert(0); } + override void visit(AST.WithStatement) { assert(0); } + override void visit(AST.TryCatchStatement) { assert(0); } + override void visit(AST.TryFinallyStatement) { assert(0); } + override void visit(AST.ThrowStatement) { assert(0); } + override void visit(AST.AsmStatement) { assert(0); } + override void visit(AST.ExpStatement) { assert(0); } + override void visit(AST.CompoundStatement) { assert(0); } + override void visit(AST.CompoundDeclarationStatement) { assert(0); } + override void visit(AST.CompoundAsmStatement) { assert(0); } + override void visit(AST.Type) { assert(0); } + override void visit(AST.TypeBasic) { assert(0); } + override void visit(AST.TypeError) { assert(0); } + override void visit(AST.TypeNull) { assert(0); } + override void visit(AST.TypeVector) { assert(0); } + override void visit(AST.TypeEnum) { assert(0); } + override void visit(AST.TypeTuple) { assert(0); } + override void visit(AST.TypeClass) { assert(0); } + override void visit(AST.TypeStruct) { assert(0); } + override void visit(AST.TypeNext) { assert(0); } + override void visit(AST.TypeReference) { assert(0); } + override void visit(AST.TypeSlice) { assert(0); } + override void visit(AST.TypeDelegate) { assert(0); } + override void visit(AST.TypePointer) { assert(0); } + override void visit(AST.TypeFunction) { assert(0); } + override void visit(AST.TypeArray) { assert(0); } + override void visit(AST.TypeDArray) { assert(0); } + override void visit(AST.TypeAArray) { assert(0); } + override void visit(AST.TypeSArray) { assert(0); } + override void visit(AST.TypeQualified) { assert(0); } + override void visit(AST.TypeIdentifier) { assert(0); } + override void visit(AST.TypeReturn) { assert(0); } + override void visit(AST.TypeTypeof) { assert(0); } + override void visit(AST.TypeInstance) { assert(0); } + override void visit(AST.Expression) { assert(0); } + override void visit(AST.DeclarationExp) { assert(0); } + override void visit(AST.IntegerExp) { assert(0); } + override void visit(AST.NewAnonClassExp) { assert(0); } + override void visit(AST.IsExp) { assert(0); } + override void visit(AST.RealExp) { assert(0); } + override void visit(AST.NullExp) { assert(0); } + override void visit(AST.TypeidExp) { assert(0); } + override void visit(AST.TraitsExp) { assert(0); } + override void visit(AST.StringExp) { assert(0); } + override void visit(AST.NewExp) { assert(0); } + override void visit(AST.AssocArrayLiteralExp) { assert(0); } + override void visit(AST.ArrayLiteralExp) { assert(0); } + override void visit(AST.FuncExp) { assert(0); } + override void visit(AST.IntervalExp) { assert(0); } + override void visit(AST.TypeExp) { assert(0); } + override void visit(AST.ScopeExp) { assert(0); } + override void visit(AST.IdentifierExp) { assert(0); } + override void visit(AST.UnaExp) { assert(0); } + override void visit(AST.DefaultInitExp) { assert(0); } + override void visit(AST.BinExp) { assert(0); } + override void visit(AST.DsymbolExp) { assert(0); } + override void visit(AST.TemplateExp) { assert(0); } + override void visit(AST.SymbolExp) { assert(0); } + override void visit(AST.VarExp) { assert(0); } + override void visit(AST.TupleExp) { assert(0); } + override void visit(AST.DollarExp) { assert(0); } + override void visit(AST.ThisExp) { assert(0); } + override void visit(AST.SuperExp) { assert(0); } + override void visit(AST.AddrExp) { assert(0); } + override void visit(AST.PreExp) { assert(0); } + override void visit(AST.PtrExp) { assert(0); } + override void visit(AST.NegExp) { assert(0); } + override void visit(AST.UAddExp) { assert(0); } + override void visit(AST.NotExp) { assert(0); } + override void visit(AST.ComExp) { assert(0); } + override void visit(AST.DeleteExp) { assert(0); } + override void visit(AST.CastExp) { assert(0); } + override void visit(AST.CallExp) { assert(0); } + override void visit(AST.DotIdExp) { assert(0); } + override void visit(AST.AssertExp) { assert(0); } + override void visit(AST.CompileExp) { assert(0); } + override void visit(AST.ImportExp) { assert(0); } + override void visit(AST.DotTemplateInstanceExp) { assert(0); } + override void visit(AST.ArrayExp) { assert(0); } + override void visit(AST.FuncInitExp) { assert(0); } + override void visit(AST.PrettyFuncInitExp) { assert(0); } + override void visit(AST.FileInitExp) { assert(0); } + override void visit(AST.LineInitExp) { assert(0); } + override void visit(AST.ModuleInitExp) { assert(0); } + override void visit(AST.CommaExp) { assert(0); } + override void visit(AST.PostExp) { assert(0); } + override void visit(AST.PowExp) { assert(0); } + override void visit(AST.MulExp) { assert(0); } + override void visit(AST.DivExp) { assert(0); } + override void visit(AST.ModExp) { assert(0); } + override void visit(AST.AddExp) { assert(0); } + override void visit(AST.MinExp) { assert(0); } + override void visit(AST.CatExp) { assert(0); } + override void visit(AST.ShlExp) { assert(0); } + override void visit(AST.ShrExp) { assert(0); } + override void visit(AST.UshrExp) { assert(0); } + override void visit(AST.EqualExp) { assert(0); } + override void visit(AST.InExp) { assert(0); } + override void visit(AST.IdentityExp) { assert(0); } + override void visit(AST.CmpExp) { assert(0); } + override void visit(AST.AndExp) { assert(0); } + override void visit(AST.XorExp) { assert(0); } + override void visit(AST.OrExp) { assert(0); } + override void visit(AST.LogicalExp) { assert(0); } + override void visit(AST.CondExp) { assert(0); } + override void visit(AST.AssignExp) { assert(0); } + override void visit(AST.BinAssignExp) { assert(0); } + override void visit(AST.AddAssignExp) { assert(0); } + override void visit(AST.MinAssignExp) { assert(0); } + override void visit(AST.MulAssignExp) { assert(0); } + override void visit(AST.DivAssignExp) { assert(0); } + override void visit(AST.ModAssignExp) { assert(0); } + override void visit(AST.PowAssignExp) { assert(0); } + override void visit(AST.AndAssignExp) { assert(0); } + override void visit(AST.OrAssignExp) { assert(0); } + override void visit(AST.XorAssignExp) { assert(0); } + override void visit(AST.ShlAssignExp) { assert(0); } + override void visit(AST.ShrAssignExp) { assert(0); } + override void visit(AST.UshrAssignExp) { assert(0); } + override void visit(AST.CatAssignExp) { assert(0); } + override void visit(AST.TemplateParameter) { assert(0); } + override void visit(AST.TemplateAliasParameter) { assert(0); } + override void visit(AST.TemplateTypeParameter) { assert(0); } + override void visit(AST.TemplateTupleParameter) { assert(0); } + override void visit(AST.TemplateValueParameter) { assert(0); } + override void visit(AST.TemplateThisParameter) { assert(0); } + override void visit(AST.Condition) { assert(0); } + override void visit(AST.StaticIfCondition) { assert(0); } + override void visit(AST.DVCondition) { assert(0); } + override void visit(AST.DebugCondition) { assert(0); } + override void visit(AST.VersionCondition) { assert(0); } + override void visit(AST.Initializer) { assert(0); } + override void visit(AST.ExpInitializer) { assert(0); } + override void visit(AST.StructInitializer) { assert(0); } + override void visit(AST.ArrayInitializer) { assert(0); } + override void visit(AST.VoidInitializer) { assert(0); } } diff --git a/src/ddmd/templateparamsem.d b/src/ddmd/templateparamsem.d index 0408563a7d7d..12de52cde253 100644 --- a/src/ddmd/templateparamsem.d +++ b/src/ddmd/templateparamsem.d @@ -47,7 +47,7 @@ extern(C++) bool tpsemantic(TemplateParameter tp, Scope* sc, TemplateParameters* private extern (C++) final class TemplateParameterSemanticVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Scope* sc; TemplateParameters* parameters; diff --git a/src/ddmd/tocsym.d b/src/ddmd/tocsym.d index df45be23abbf..4a705b8e6872 100644 --- a/src/ddmd/tocsym.d +++ b/src/ddmd/tocsym.d @@ -112,7 +112,7 @@ Symbol *toSymbol(Dsymbol s) { extern (C++) static final class ToSymbol : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Symbol *result; diff --git a/src/ddmd/toctype.d b/src/ddmd/toctype.d index 389944eacbd0..476f51be3ad8 100644 --- a/src/ddmd/toctype.d +++ b/src/ddmd/toctype.d @@ -29,7 +29,7 @@ import ddmd.visitor; private extern (C++) final class ToCtypeVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: extern (D) this() { diff --git a/src/ddmd/tocvdebug.d b/src/ddmd/tocvdebug.d index feb32d76a9c1..7734fd459df1 100644 --- a/src/ddmd/tocvdebug.d +++ b/src/ddmd/tocvdebug.d @@ -786,7 +786,7 @@ int cvMember(Dsymbol s, ubyte *p) result = 0; } - alias visit = super.visit; + alias visit = Visitor.visit; override void visit(Dsymbol s) { diff --git a/src/ddmd/todt.d b/src/ddmd/todt.d index 90e7b2937e4b..7837c629e5b0 100644 --- a/src/ddmd/todt.d +++ b/src/ddmd/todt.d @@ -72,7 +72,7 @@ extern (C++) void Initializer_toDt(Initializer init, DtBuilder dtb) this.dtb = dtb; } - alias visit = super.visit; + alias visit = Visitor.visit; override void visit(Initializer) { @@ -229,7 +229,7 @@ extern (C++) void Expression_toDt(Expression e, DtBuilder dtb) this.dtb = dtb; } - alias visit = super.visit; + alias visit = Visitor.visit; override void visit(Expression e) { @@ -855,7 +855,7 @@ extern (C++) void Type_toDt(Type t, DtBuilder dtb) this.dtb = dtb; } - alias visit = super.visit; + alias visit = Visitor.visit; override void visit(Type t) { @@ -978,7 +978,7 @@ private extern (C++) class TypeInfoDtVisitor : Visitor this.dtb = dtb; } - alias visit = super.visit; + alias visit = Visitor.visit; override void visit(TypeInfoDeclaration d) { diff --git a/src/ddmd/toobj.d b/src/ddmd/toobj.d index 3564c1ab174a..20c901b4faa7 100644 --- a/src/ddmd/toobj.d +++ b/src/ddmd/toobj.d @@ -282,7 +282,7 @@ void toObjFile(Dsymbol ds, bool multiobj) //printf("toObjFile(%s)\n", ds.toChars()); extern (C++) final class ToObjFile : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: bool multiobj; diff --git a/src/ddmd/traits.d b/src/ddmd/traits.d index 7aaa24595383..3729c1539ba7 100644 --- a/src/ddmd/traits.d +++ b/src/ddmd/traits.d @@ -184,7 +184,7 @@ extern (C++) d_uns64 getTypePointerBitmap(Loc loc, Type t, Array!(d_uns64)* data extern (C++) final class PointerBitmapVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: extern (D) this(Array!(d_uns64)* _data, d_uns64 _sz_size_t) { diff --git a/src/ddmd/transitivevisitor.d b/src/ddmd/transitivevisitor.d index 32c4d726e480..5b04ed1a7128 100644 --- a/src/ddmd/transitivevisitor.d +++ b/src/ddmd/transitivevisitor.d @@ -2,7 +2,6 @@ module ddmd.transitivevisitor; // Online documentation: https://dlang.org/phobos/ddmd_transitivevisitor.html -import ddmd.astbase; import ddmd.permissivevisitor; import ddmd.tokens; @@ -12,31 +11,31 @@ import core.stdc.stdio; /** Visitor that implements the AST traversal logic. The nodes just accept their children. */ -class TransitiveVisitor : PermissiveVisitor +extern(C++) class TransitiveVisitor(AST) : PermissiveVisitor!AST { - alias visit = super.visit; + alias visit = PermissiveVisitor!AST.visit; // Statement Nodes //=========================================================== - override void visit(ASTBase.ExpStatement s) + override void visit(AST.ExpStatement s) { //printf("Visiting ExpStatement\n"); if (s.exp && s.exp.op == TOKdeclaration) { - (cast(ASTBase.DeclarationExp)s.exp).declaration.accept(this); + (cast(AST.DeclarationExp)s.exp).declaration.accept(this); return; } if (s.exp) s.exp.accept(this); } - override void visit(ASTBase.CompileStatement s) + override void visit(AST.CompileStatement s) { //printf("Visiting CompileStatement\n"); s.exp.accept(this); } - override void visit(ASTBase.CompoundStatement s) + override void visit(AST.CompoundStatement s) { //printf("Visiting CompoundStatement\n"); foreach (sx; *s.statements) @@ -46,7 +45,7 @@ class TransitiveVisitor : PermissiveVisitor } } - void visitVarDecl(ASTBase.VarDeclaration v) + void visitVarDecl(AST.VarDeclaration v) { //printf("Visiting VarDeclaration\n"); if (v.type) @@ -55,13 +54,13 @@ class TransitiveVisitor : PermissiveVisitor { auto ie = v._init.isExpInitializer(); if (ie && (ie.exp.op == TOKconstruct || ie.exp.op == TOKblit)) - (cast(ASTBase.AssignExp)ie.exp).e2.accept(this); + (cast(AST.AssignExp)ie.exp).e2.accept(this); else v._init.accept(this); } } - override void visit(ASTBase.CompoundDeclarationStatement s) + override void visit(AST.CompoundDeclarationStatement s) { //printf("Visiting CompoundDeclarationStatement\n"); foreach (sx; *s.statements) @@ -69,7 +68,7 @@ class TransitiveVisitor : PermissiveVisitor auto ds = sx ? sx.isExpStatement() : null; if (ds && ds.exp.op == TOKdeclaration) { - auto d = (cast(ASTBase.DeclarationExp)ds.exp).declaration; + auto d = (cast(AST.DeclarationExp)ds.exp).declaration; assert(d.isDeclaration()); if (auto v = d.isVarDeclaration()) visitVarDecl(v); @@ -79,14 +78,14 @@ class TransitiveVisitor : PermissiveVisitor } } - override void visit(ASTBase.ScopeStatement s) + override void visit(AST.ScopeStatement s) { //printf("Visiting ScopeStatement\n"); if (s.statement) s.statement.accept(this); } - override void visit(ASTBase.WhileStatement s) + override void visit(AST.WhileStatement s) { //printf("Visiting WhileStatement\n"); s.condition.accept(this); @@ -94,7 +93,7 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.DoStatement s) + override void visit(AST.DoStatement s) { //printf("Visiting DoStatement\n"); if (s._body) @@ -102,7 +101,7 @@ class TransitiveVisitor : PermissiveVisitor s.condition.accept(this); } - override void visit(ASTBase.ForStatement s) + override void visit(AST.ForStatement s) { //printf("Visiting ForStatement\n"); if (s._init) @@ -115,7 +114,7 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.ForeachStatement s) + override void visit(AST.ForeachStatement s) { //printf("Visiting ForeachStatement\n"); foreach (p; *s.parameters) @@ -126,7 +125,7 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.ForeachRangeStatement s) + override void visit(AST.ForeachRangeStatement s) { //printf("Visiting ForeachRangeStatement\n"); if (s.prm.type) @@ -137,7 +136,7 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.IfStatement s) + override void visit(AST.IfStatement s) { //printf("Visiting IfStatement\n"); if (s.prm && s.prm.type) @@ -148,7 +147,7 @@ class TransitiveVisitor : PermissiveVisitor s.elsebody.accept(this); } - override void visit(ASTBase.ConditionalStatement s) + override void visit(AST.ConditionalStatement s) { //printf("Visiting ConditionalStatement\n"); s.condition.accept(this); @@ -158,7 +157,7 @@ class TransitiveVisitor : PermissiveVisitor s.elsebody.accept(this); } - void visitArgs(ASTBase.Expressions* expressions, ASTBase.Expression basis = null) + void visitArgs(AST.Expressions* expressions, AST.Expression basis = null) { if (!expressions || !expressions.dim) return; @@ -171,7 +170,7 @@ class TransitiveVisitor : PermissiveVisitor } } - override void visit(ASTBase.PragmaStatement s) + override void visit(AST.PragmaStatement s) { //printf("Visiting PragmaStatement\n"); if (s.args && s.args.dim) @@ -180,13 +179,13 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.StaticAssertStatement s) + override void visit(AST.StaticAssertStatement s) { //printf("Visiting StaticAssertStatement\n"); s.sa.accept(this); } - override void visit(ASTBase.SwitchStatement s) + override void visit(AST.SwitchStatement s) { //printf("Visiting SwitchStatement\n"); s.condition.accept(this); @@ -194,14 +193,14 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.CaseStatement s) + override void visit(AST.CaseStatement s) { //printf("Visiting CaseStatement\n"); s.exp.accept(this); s.statement.accept(this); } - override void visit(ASTBase.CaseRangeStatement s) + override void visit(AST.CaseRangeStatement s) { //printf("Visiting CaseRangeStatement\n"); s.first.accept(this); @@ -209,27 +208,27 @@ class TransitiveVisitor : PermissiveVisitor s.statement.accept(this); } - override void visit(ASTBase.DefaultStatement s) + override void visit(AST.DefaultStatement s) { //printf("Visiting DefaultStatement\n"); s.statement.accept(this); } - override void visit(ASTBase.GotoCaseStatement s) + override void visit(AST.GotoCaseStatement s) { //printf("Visiting GotoCaseStatement\n"); if (s.exp) s.exp.accept(this); } - override void visit(ASTBase.ReturnStatement s) + override void visit(AST.ReturnStatement s) { //printf("Visiting ReturnStatement\n"); if (s.exp) s.exp.accept(this); } - override void visit(ASTBase.SynchronizedStatement s) + override void visit(AST.SynchronizedStatement s) { //printf("Visiting SynchronizedStatement\n"); if (s.exp) @@ -238,7 +237,7 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.WithStatement s) + override void visit(AST.WithStatement s) { //printf("Visiting WithStatement\n"); s.exp.accept(this); @@ -246,7 +245,7 @@ class TransitiveVisitor : PermissiveVisitor s._body.accept(this); } - override void visit(ASTBase.TryCatchStatement s) + override void visit(AST.TryCatchStatement s) { //printf("Visiting TryCatchStatement\n"); if (s._body) @@ -255,40 +254,40 @@ class TransitiveVisitor : PermissiveVisitor visit(c); } - override void visit(ASTBase.TryFinallyStatement s) + override void visit(AST.TryFinallyStatement s) { //printf("Visiting TryFinallyStatement\n"); s._body.accept(this); s.finalbody.accept(this); } - override void visit(ASTBase.OnScopeStatement s) + override void visit(AST.OnScopeStatement s) { //printf("Visiting OnScopeStatement\n"); s.statement.accept(this); } - override void visit(ASTBase.ThrowStatement s) + override void visit(AST.ThrowStatement s) { //printf("Visiting ThrowStatement\n"); s.exp.accept(this); } - override void visit(ASTBase.LabelStatement s) + override void visit(AST.LabelStatement s) { //printf("Visiting LabelStatement\n"); if (s.statement) s.statement.accept(this); } - override void visit(ASTBase.ImportStatement s) + override void visit(AST.ImportStatement s) { //printf("Visiting ImportStatement\n"); foreach (imp; *s.imports) imp.accept(this); } - void visit(ASTBase.Catch c) + void visit(AST.Catch c) { //printf("Visiting Catch\n"); if (c.type) @@ -300,21 +299,21 @@ class TransitiveVisitor : PermissiveVisitor // Type Nodes //============================================================ - void visitType(ASTBase.Type t) + void visitType(AST.Type t) { //printf("Visiting Type\n"); if (!t) return; - if (t.ty == ASTBase.Tfunction) + if (t.ty == AST.Tfunction) { - visitFunctionType(cast(ASTBase.TypeFunction)t, null); + visitFunctionType(cast(AST.TypeFunction)t, null); return; } else t.accept(this); } - void visitFunctionType(ASTBase.TypeFunction t, ASTBase.TemplateDeclaration td) + void visitFunctionType(AST.TypeFunction t, AST.TemplateDeclaration td) { if (t.next) visitType(t.next); @@ -326,20 +325,20 @@ class TransitiveVisitor : PermissiveVisitor visitParameters(t.parameters); } - void visitParameters(ASTBase.Parameters* parameters) + void visitParameters(AST.Parameters* parameters) { if (parameters) { - size_t dim = ASTBase.Parameter.dim(parameters); + size_t dim = AST.Parameter.dim(parameters); foreach(i; 0..dim) { - ASTBase.Parameter fparam = ASTBase.Parameter.getNth(parameters, i); + AST.Parameter fparam = AST.Parameter.getNth(parameters, i); fparam.accept(this); } } } - override void visit(ASTBase.TypeVector t) + override void visit(AST.TypeVector t) { //printf("Visiting TypeVector\n"); if (!t.basetype) @@ -347,101 +346,101 @@ class TransitiveVisitor : PermissiveVisitor t.basetype.accept(this); } - override void visit(ASTBase.TypeSArray t) + override void visit(AST.TypeSArray t) { //printf("Visiting TypeSArray\n"); t.next.accept(this); } - override void visit(ASTBase.TypeDArray t) + override void visit(AST.TypeDArray t) { //printf("Visiting TypeDArray\n"); t.next.accept(this); } - override void visit(ASTBase.TypeAArray t) + override void visit(AST.TypeAArray t) { //printf("Visiting TypeAArray\n"); t.next.accept(this); t.index.accept(this); } - override void visit(ASTBase.TypePointer t) + override void visit(AST.TypePointer t) { //printf("Visiting TypePointer\n"); - if (t.next.ty == ASTBase.Tfunction) + if (t.next.ty == AST.Tfunction) { - visitFunctionType(cast(ASTBase.TypeFunction)t.next, null); + visitFunctionType(cast(AST.TypeFunction)t.next, null); } else t.next.accept(this); } - override void visit(ASTBase.TypeReference t) + override void visit(AST.TypeReference t) { //printf("Visiting TypeReference\n"); t.next.accept(this); } - override void visit(ASTBase.TypeFunction t) + override void visit(AST.TypeFunction t) { //printf("Visiting TypeFunction\n"); visitFunctionType(t, null); } - override void visit(ASTBase.TypeDelegate t) + override void visit(AST.TypeDelegate t) { //printf("Visiting TypeDelegate\n"); - visitFunctionType(cast(ASTBase.TypeFunction)t.next, null); + visitFunctionType(cast(AST.TypeFunction)t.next, null); } - void visitTypeQualified(ASTBase.TypeQualified t) + void visitTypeQualified(AST.TypeQualified t) { //printf("Visiting TypeQualified\n"); foreach (id; t.idents) { if (id.dyncast() == DYNCAST.dsymbol) - (cast(ASTBase.TemplateInstance)id).accept(this); + (cast(AST.TemplateInstance)id).accept(this); else if (id.dyncast() == DYNCAST.expression) - (cast(ASTBase.Expression)id).accept(this); + (cast(AST.Expression)id).accept(this); else if (id.dyncast() == DYNCAST.type) - (cast(ASTBase.Type)id).accept(this); + (cast(AST.Type)id).accept(this); } } - override void visit(ASTBase.TypeIdentifier t) + override void visit(AST.TypeIdentifier t) { //printf("Visiting TypeIdentifier\n"); visitTypeQualified(t); } - override void visit(ASTBase.TypeInstance t) + override void visit(AST.TypeInstance t) { //printf("Visiting TypeInstance\n"); t.tempinst.accept(this); visitTypeQualified(t); } - override void visit(ASTBase.TypeTypeof t) + override void visit(AST.TypeTypeof t) { //printf("Visiting TypeTypeof\n"); t.exp.accept(this); visitTypeQualified(t); } - override void visit(ASTBase.TypeReturn t) + override void visit(AST.TypeReturn t) { //printf("Visiting TypeReturn\n"); visitTypeQualified(t); } - override void visit(ASTBase.TypeTuple t) + override void visit(AST.TypeTuple t) { //printf("Visiting TypeTuple\n"); visitParameters(t.arguments); } - override void visit(ASTBase.TypeSlice t) + override void visit(AST.TypeSlice t) { //printf("Visiting TypeSlice\n"); t.next.accept(this); @@ -452,7 +451,7 @@ class TransitiveVisitor : PermissiveVisitor // Miscellaneous //======================================================== - override void visit(ASTBase.StaticAssert s) + override void visit(AST.StaticAssert s) { //printf("Visiting StaticAssert\n"); s.exp.accept(this); @@ -460,7 +459,7 @@ class TransitiveVisitor : PermissiveVisitor s.msg.accept(this); } - override void visit(ASTBase.EnumMember em) + override void visit(AST.EnumMember em) { //printf("Visiting EnumMember\n"); if (em.type) @@ -471,71 +470,71 @@ class TransitiveVisitor : PermissiveVisitor // Declarations //========================================================= - void visitAttribDeclaration(ASTBase.AttribDeclaration d) + void visitAttribDeclaration(AST.AttribDeclaration d) { if (d.decl) foreach (de; *d.decl) de.accept(this); } - override void visit(ASTBase.AttribDeclaration d) + override void visit(AST.AttribDeclaration d) { //printf("Visiting AttribDeclaration\n"); visitAttribDeclaration(d); } - override void visit(ASTBase.StorageClassDeclaration d) + override void visit(AST.StorageClassDeclaration d) { //printf("Visiting StorageClassDeclaration\n"); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.DeprecatedDeclaration d) + override void visit(AST.DeprecatedDeclaration d) { //printf("Visiting DeprecatedDeclaration\n"); d.msg.accept(this); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.LinkDeclaration d) + override void visit(AST.LinkDeclaration d) { //printf("Visiting LinkDeclaration\n"); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.CPPMangleDeclaration d) + override void visit(AST.CPPMangleDeclaration d) { //printf("Visiting CPPMangleDeclaration\n"); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.ProtDeclaration d) + override void visit(AST.ProtDeclaration d) { //printf("Visiting ProtDeclaration\n"); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.AlignDeclaration d) + override void visit(AST.AlignDeclaration d) { //printf("Visiting AlignDeclaration\n"); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.AnonDeclaration d) + override void visit(AST.AnonDeclaration d) { //printf("Visiting AnonDeclaration\n"); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.PragmaDeclaration d) + override void visit(AST.PragmaDeclaration d) { //printf("Visiting PragmaDeclaration\n"); if (d.args && d.args.dim) visitArgs(d.args); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - override void visit(ASTBase.ConditionalDeclaration d) + override void visit(AST.ConditionalDeclaration d) { //printf("Visiting ConditionalDeclaration\n"); d.condition.accept(this); @@ -547,20 +546,20 @@ class TransitiveVisitor : PermissiveVisitor de.accept(this); } - override void visit(ASTBase.CompileDeclaration d) + override void visit(AST.CompileDeclaration d) { //printf("Visiting compileDeclaration\n"); d.exp.accept(this); } - override void visit(ASTBase.UserAttributeDeclaration d) + override void visit(AST.UserAttributeDeclaration d) { //printf("Visiting UserAttributeDeclaration\n"); visitArgs(d.atts); - visitAttribDeclaration(cast(ASTBase.AttribDeclaration)d); + visitAttribDeclaration(cast(AST.AttribDeclaration)d); } - void visitFuncBody(ASTBase.FuncDeclaration f) + void visitFuncBody(AST.FuncDeclaration f) { //printf("Visiting funcBody\n"); if (!f.fbody) @@ -572,7 +571,7 @@ class TransitiveVisitor : PermissiveVisitor f.fbody.accept(this); } - void visitBaseClasses(ASTBase.ClassDeclaration d) + void visitBaseClasses(AST.ClassDeclaration d) { //printf("Visiting ClassDeclaration\n"); if (!d || !d.baseclasses.dim) @@ -581,19 +580,19 @@ class TransitiveVisitor : PermissiveVisitor visitType(b.type); } - bool visitEponymousMember(ASTBase.TemplateDeclaration d) + bool visitEponymousMember(AST.TemplateDeclaration d) { //printf("Visiting EponymousMember\n"); if (!d.members || d.members.dim != 1) return false; - ASTBase.Dsymbol onemember = (*d.members)[0]; + AST.Dsymbol onemember = (*d.members)[0]; if (onemember.ident != d.ident) return false; - if (ASTBase.FuncDeclaration fd = onemember.isFuncDeclaration()) + if (AST.FuncDeclaration fd = onemember.isFuncDeclaration()) { assert(fd.type); - visitFunctionType(cast(ASTBase.TypeFunction)fd.type, d); + visitFunctionType(cast(AST.TypeFunction)fd.type, d); if (d.constraint) d.constraint.accept(this); visitFuncBody(fd); @@ -601,7 +600,7 @@ class TransitiveVisitor : PermissiveVisitor return true; } - if (ASTBase.AggregateDeclaration ad = onemember.isAggregateDeclaration()) + if (AST.AggregateDeclaration ad = onemember.isAggregateDeclaration()) { visitTemplateParameters(d.parameters); if (d.constraint) @@ -615,7 +614,7 @@ class TransitiveVisitor : PermissiveVisitor return true; } - if (ASTBase.VarDeclaration vd = onemember.isVarDeclaration()) + if (AST.VarDeclaration vd = onemember.isVarDeclaration()) { if (d.constraint) return false; @@ -624,9 +623,9 @@ class TransitiveVisitor : PermissiveVisitor visitTemplateParameters(d.parameters); if (vd._init) { - ASTBase.ExpInitializer ie = vd._init.isExpInitializer(); + AST.ExpInitializer ie = vd._init.isExpInitializer(); if (ie && (ie.exp.op == TOKconstruct || ie.exp.op == TOKblit)) - (cast(ASTBase.AssignExp)ie.exp).e2.accept(this); + (cast(AST.AssignExp)ie.exp).e2.accept(this); else vd._init.accept(this); @@ -637,7 +636,7 @@ class TransitiveVisitor : PermissiveVisitor return false; } - void visitTemplateParameters(ASTBase.TemplateParameters* parameters) + void visitTemplateParameters(AST.TemplateParameters* parameters) { if (!parameters || !parameters.dim) return; @@ -645,7 +644,7 @@ class TransitiveVisitor : PermissiveVisitor p.accept(this); } - override void visit(ASTBase.TemplateDeclaration d) + override void visit(AST.TemplateDeclaration d) { //printf("Visiting TemplateDeclaration\n"); if (visitEponymousMember(d)) @@ -661,15 +660,15 @@ class TransitiveVisitor : PermissiveVisitor void visitObject(RootObject oarg) { - if (auto t = ASTBase.isType(oarg)) + if (auto t = AST.isType(oarg)) { visitType(t); } - else if (auto e = ASTBase.isExpression(oarg)) + else if (auto e = AST.isExpression(oarg)) { e.accept(this); } - else if (auto v = ASTBase.isTuple(oarg)) + else if (auto v = AST.isTuple(oarg)) { auto args = &v.objects; foreach (arg; *args) @@ -677,7 +676,7 @@ class TransitiveVisitor : PermissiveVisitor } } - void visitTiargs(ASTBase.TemplateInstance ti) + void visitTiargs(AST.TemplateInstance ti) { //printf("Visiting tiargs\n"); if (!ti.tiargs) @@ -688,20 +687,20 @@ class TransitiveVisitor : PermissiveVisitor } } - override void visit(ASTBase.TemplateInstance ti) + override void visit(AST.TemplateInstance ti) { //printf("Visiting TemplateInstance\n"); visitTiargs(ti); } - override void visit(ASTBase.TemplateMixin tm) + override void visit(AST.TemplateMixin tm) { //printf("Visiting TemplateMixin\n"); visitType(tm.tqual); visitTiargs(tm); } - override void visit(ASTBase.EnumDeclaration d) + override void visit(AST.EnumDeclaration d) { //printf("Visiting EnumDeclaration\n"); if (d.memtype) @@ -716,14 +715,14 @@ class TransitiveVisitor : PermissiveVisitor } } - override void visit(ASTBase.Nspace d) + override void visit(AST.Nspace d) { //printf("Visiting Nspace\n"); foreach(s; *d.members) s.accept(this); } - override void visit(ASTBase.StructDeclaration d) + override void visit(AST.StructDeclaration d) { //printf("Visiting StructDeclaration\n"); if (!d.members) @@ -732,7 +731,7 @@ class TransitiveVisitor : PermissiveVisitor s.accept(this); } - override void visit(ASTBase.ClassDeclaration d) + override void visit(AST.ClassDeclaration d) { //printf("Visiting ClassDeclaration\n"); visitBaseClasses(d); @@ -741,7 +740,7 @@ class TransitiveVisitor : PermissiveVisitor s.accept(this); } - override void visit(ASTBase.AliasDeclaration d) + override void visit(AST.AliasDeclaration d) { //printf("Visting AliasDeclaration\n"); if (d.aliassym) @@ -750,82 +749,82 @@ class TransitiveVisitor : PermissiveVisitor visitType(d.type); } - override void visit(ASTBase.VarDeclaration d) + override void visit(AST.VarDeclaration d) { //printf("Visiting VarDeclaration\n"); visitVarDecl(d); } - override void visit(ASTBase.FuncDeclaration f) + override void visit(AST.FuncDeclaration f) { //printf("Visiting FuncDeclaration\n"); - auto tf = cast(ASTBase.TypeFunction)f.type; + auto tf = cast(AST.TypeFunction)f.type; visitType(tf); visitFuncBody(f); } - override void visit(ASTBase.FuncLiteralDeclaration f) + override void visit(AST.FuncLiteralDeclaration f) { //printf("Visiting FuncLiteralDeclaration\n"); - if (f.type.ty == ASTBase.Terror) + if (f.type.ty == AST.Terror) return; - ASTBase.TypeFunction tf = cast(ASTBase.TypeFunction)f.type; + AST.TypeFunction tf = cast(AST.TypeFunction)f.type; if (!f.inferRetType && tf.next) visitType(tf.next); visitParameters(tf.parameters); - ASTBase.CompoundStatement cs = f.fbody.isCompoundStatement(); - ASTBase.Statement s = !cs ? f.fbody : null; - ASTBase.ReturnStatement rs = s ? s.isReturnStatement() : null; + AST.CompoundStatement cs = f.fbody.isCompoundStatement(); + AST.Statement s = !cs ? f.fbody : null; + AST.ReturnStatement rs = s ? s.isReturnStatement() : null; if (rs && rs.exp) rs.exp.accept(this); else visitFuncBody(f); } - override void visit(ASTBase.PostBlitDeclaration d) + override void visit(AST.PostBlitDeclaration d) { //printf("Visiting PostBlitDeclaration\n"); visitFuncBody(d); } - override void visit(ASTBase.DtorDeclaration d) + override void visit(AST.DtorDeclaration d) { //printf("Visiting DtorDeclaration\n"); visitFuncBody(d); } - override void visit(ASTBase.StaticCtorDeclaration d) + override void visit(AST.StaticCtorDeclaration d) { //printf("Visiting StaticCtorDeclaration\n"); visitFuncBody(d); } - override void visit(ASTBase.StaticDtorDeclaration d) + override void visit(AST.StaticDtorDeclaration d) { //printf("Visiting StaticDtorDeclaration\n"); visitFuncBody(d); } - override void visit(ASTBase.InvariantDeclaration d) + override void visit(AST.InvariantDeclaration d) { //printf("Visiting InvariantDeclaration\n"); visitFuncBody(d); } - override void visit(ASTBase.UnitTestDeclaration d) + override void visit(AST.UnitTestDeclaration d) { //printf("Visiting UnitTestDeclaration\n"); visitFuncBody(d); } - override void visit(ASTBase.NewDeclaration d) + override void visit(AST.NewDeclaration d) { //printf("Visiting NewDeclaration\n"); visitParameters(d.parameters); visitFuncBody(d); } - override void visit(ASTBase.DeleteDeclaration d) + override void visit(AST.DeleteDeclaration d) { //printf("Visiting DeleteDeclaration\n"); visitParameters(d.parameters); @@ -835,7 +834,7 @@ class TransitiveVisitor : PermissiveVisitor // Initializers //============================================================ - override void visit(ASTBase.StructInitializer si) + override void visit(AST.StructInitializer si) { //printf("Visiting StructInitializer\n"); foreach (i, const id; si.field) @@ -843,7 +842,7 @@ class TransitiveVisitor : PermissiveVisitor iz.accept(this); } - override void visit(ASTBase.ArrayInitializer ai) + override void visit(AST.ArrayInitializer ai) { //printf("Visiting ArrayInitializer\n"); foreach (i, ex; ai.index) @@ -855,7 +854,7 @@ class TransitiveVisitor : PermissiveVisitor } } - override void visit(ASTBase.ExpInitializer ei) + override void visit(AST.ExpInitializer ei) { //printf("Visiting ExpInitializer\n"); ei.exp.accept(this); @@ -864,13 +863,13 @@ class TransitiveVisitor : PermissiveVisitor // Expressions //=================================================== - override void visit(ASTBase.ArrayLiteralExp e) + override void visit(AST.ArrayLiteralExp e) { //printf("Visiting ArrayLiteralExp\n"); visitArgs(e.elements, e.basis); } - override void visit(ASTBase.AssocArrayLiteralExp e) + override void visit(AST.AssocArrayLiteralExp e) { //printf("Visiting AssocArrayLiteralExp\n"); foreach (i, key; *e.keys) @@ -880,20 +879,20 @@ class TransitiveVisitor : PermissiveVisitor } } - override void visit(ASTBase.TypeExp e) + override void visit(AST.TypeExp e) { //printf("Visiting TypeExp\n"); visitType(e.type); } - override void visit(ASTBase.ScopeExp e) + override void visit(AST.ScopeExp e) { //printf("Visiting ScopeExp\n"); if (e.sds.isTemplateInstance()) e.sds.accept(this); } - override void visit(ASTBase.NewExp e) + override void visit(AST.NewExp e) { //printf("Visiting NewExp\n"); if (e.thisexp) @@ -905,7 +904,7 @@ class TransitiveVisitor : PermissiveVisitor visitArgs(e.arguments); } - override void visit(ASTBase.NewAnonClassExp e) + override void visit(AST.NewAnonClassExp e) { //printf("Visiting NewAnonClassExp\n"); if (e.thisexp) @@ -918,7 +917,7 @@ class TransitiveVisitor : PermissiveVisitor e.cd.accept(this); } - override void visit(ASTBase.TupleExp e) + override void visit(AST.TupleExp e) { //printf("Visiting TupleExp\n"); if (e.e0) @@ -926,13 +925,13 @@ class TransitiveVisitor : PermissiveVisitor visitArgs(e.exps); } - override void visit(ASTBase.FuncExp e) + override void visit(AST.FuncExp e) { //printf("Visiting FuncExp\n"); e.fd.accept(this); } - override void visit(ASTBase.DeclarationExp e) + override void visit(AST.DeclarationExp e) { //printf("Visiting DeclarationExp\n"); if (auto v = e.declaration.isVarDeclaration()) @@ -941,13 +940,13 @@ class TransitiveVisitor : PermissiveVisitor e.declaration.accept(this); } - override void visit(ASTBase.TypeidExp e) + override void visit(AST.TypeidExp e) { //printf("Visiting TypeidExp\n"); visitObject(e.obj); } - override void visit(ASTBase.TraitsExp e) + override void visit(AST.TraitsExp e) { //printf("Visiting TraitExp\n"); if (e.args) @@ -955,7 +954,7 @@ class TransitiveVisitor : PermissiveVisitor visitObject(arg); } - override void visit(ASTBase.IsExp e) + override void visit(AST.IsExp e) { //printf("Visiting IsExp\n"); visitType(e.targ); @@ -965,32 +964,32 @@ class TransitiveVisitor : PermissiveVisitor visitTemplateParameters(e.parameters); } - override void visit(ASTBase.UnaExp e) + override void visit(AST.UnaExp e) { //printf("Visiting UnaExp\n"); e.e1.accept(this); } - override void visit(ASTBase.BinExp e) + override void visit(AST.BinExp e) { //printf("Visiting BinExp\n"); e.e1.accept(this); e.e2.accept(this); } - override void visit(ASTBase.CompileExp e) + override void visit(AST.CompileExp e) { //printf("Visiting CompileExp\n"); e.e1.accept(this); } - override void visit(ASTBase.ImportExp e) + override void visit(AST.ImportExp e) { //printf("Visiting ImportExp\n"); e.e1.accept(this); } - override void visit(ASTBase.AssertExp e) + override void visit(AST.AssertExp e) { //printf("Visiting AssertExp\n"); e.e1.accept(this); @@ -998,39 +997,39 @@ class TransitiveVisitor : PermissiveVisitor e.msg.accept(this); } - override void visit(ASTBase.DotIdExp e) + override void visit(AST.DotIdExp e) { //printf("Visiting DotIdExp\n"); e.e1.accept(this); } - override void visit(ASTBase.DotTemplateInstanceExp e) + override void visit(AST.DotTemplateInstanceExp e) { //printf("Visiting DotTemplateInstanceExp\n"); e.e1.accept(this); e.ti.accept(this); } - override void visit(ASTBase.CallExp e) + override void visit(AST.CallExp e) { //printf("Visiting CallExp\n"); e.e1.accept(this); visitArgs(e.arguments); } - override void visit(ASTBase.PtrExp e) + override void visit(AST.PtrExp e) { //printf("Visiting PtrExp\n"); e.e1.accept(this); } - override void visit(ASTBase.DeleteExp e) + override void visit(AST.DeleteExp e) { //printf("Visiting DeleteExp\n"); e.e1.accept(this); } - override void visit(ASTBase.CastExp e) + override void visit(AST.CastExp e) { //printf("Visiting CastExp\n"); if (e.to) @@ -1038,33 +1037,33 @@ class TransitiveVisitor : PermissiveVisitor e.e1.accept(this); } - override void visit(ASTBase.IntervalExp e) + override void visit(AST.IntervalExp e) { //printf("Visiting IntervalExp\n"); e.lwr.accept(this); e.upr.accept(this); } - override void visit(ASTBase.ArrayExp e) + override void visit(AST.ArrayExp e) { //printf("Visiting ArrayExp\n"); e.e1.accept(this); visitArgs(e.arguments); } - override void visit(ASTBase.PostExp e) + override void visit(AST.PostExp e) { //printf("Visiting PostExp\n"); e.e1.accept(this); } - override void visit(ASTBase.PreExp e) + override void visit(AST.PreExp e) { //printf("Visiting PreExp\n"); e.e1.accept(this); } - override void visit(ASTBase.CondExp e) + override void visit(AST.CondExp e) { //printf("Visiting CondExp\n"); e.econd.accept(this); @@ -1075,7 +1074,7 @@ class TransitiveVisitor : PermissiveVisitor // Template Parameter //=========================================================== - override void visit(ASTBase.TemplateTypeParameter tp) + override void visit(AST.TemplateTypeParameter tp) { //printf("Visiting TemplateTypeParameter\n"); if (tp.specType) @@ -1084,13 +1083,13 @@ class TransitiveVisitor : PermissiveVisitor visitType(tp.defaultType); } - override void visit(ASTBase.TemplateThisParameter tp) + override void visit(AST.TemplateThisParameter tp) { //printf("Visiting TemplateThisParameter\n"); - visit(cast(ASTBase.TemplateTypeParameter)tp); + visit(cast(AST.TemplateTypeParameter)tp); } - override void visit(ASTBase.TemplateAliasParameter tp) + override void visit(AST.TemplateAliasParameter tp) { //printf("Visiting TemplateAliasParameter\n"); if (tp.specType) @@ -1101,7 +1100,7 @@ class TransitiveVisitor : PermissiveVisitor visitObject(tp.defaultAlias); } - override void visit(ASTBase.TemplateValueParameter tp) + override void visit(AST.TemplateValueParameter tp) { //printf("Visiting TemplateValueParameter\n"); visitType(tp.valType); @@ -1113,13 +1112,13 @@ class TransitiveVisitor : PermissiveVisitor //=========================================================== - override void visit(ASTBase.StaticIfCondition c) + override void visit(AST.StaticIfCondition c) { //printf("Visiting StaticIfCondition\n"); c.exp.accept(this); } - override void visit(ASTBase.Parameter p) + override void visit(AST.Parameter p) { //printf("Visiting Parameter\n"); visitType(p.type); @@ -1127,7 +1126,7 @@ class TransitiveVisitor : PermissiveVisitor p.defaultArg.accept(this); } - override void visit(ASTBase.Module m) + override void visit(AST.Module m) { //printf("Visiting Module\n"); foreach (s; *m.members) diff --git a/src/ddmd/typesem.d b/src/ddmd/typesem.d index 9a5a70be2a65..af4d3981bbba 100644 --- a/src/ddmd/typesem.d +++ b/src/ddmd/typesem.d @@ -64,7 +64,7 @@ extern(C++) Type typeSemantic(Type t, Loc loc, Scope* sc) private extern (C++) final class TypeToExpressionVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Expression result; Type itype; @@ -170,7 +170,7 @@ extern (C++) Expression typeToExpressionHelper(TypeQualified t, Expression e, si private extern (C++) final class TypeSemanticVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; Loc loc; Scope* sc; Type result; diff --git a/src/ddmd/typinf.d b/src/ddmd/typinf.d index 1e6818fe2a5e..968bc223fb77 100644 --- a/src/ddmd/typinf.d +++ b/src/ddmd/typinf.d @@ -120,7 +120,7 @@ extern (C++) bool isSpeculativeType(Type t) { extern (C++) final class SpeculativeTypeVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: bool result; diff --git a/src/ddmd/visitor.d b/src/ddmd/visitor.d index f1d1235c0371..2915b26ccdd1 100644 --- a/src/ddmd/visitor.d +++ b/src/ddmd/visitor.d @@ -10,1389 +10,82 @@ module ddmd.visitor; +import ddmd.astcodegen; +import ddmd.parsetimevisitor; + // Online documentation: https://dlang.org/phobos/ddmd_visitor.html -import ddmd.aggregate; -import ddmd.aliasthis; -import ddmd.attrib; -import ddmd.cond; -import ddmd.ctfeexpr; -import ddmd.dclass; -import ddmd.declaration; -import ddmd.denum; -import ddmd.dimport; -import ddmd.dmodule; -import ddmd.dstruct; -import ddmd.dsymbol; -import ddmd.dtemplate; -import ddmd.dversion; -import ddmd.expression; -import ddmd.func; -import ddmd.init; -import ddmd.mtype; -import ddmd.nspace; -import ddmd.statement; -import ddmd.staticassert; +alias Visitor = GenericVisitor!ASTCodegen; -extern (C++) class Visitor +extern (C++) class GenericVisitor(AST) : ParseTimeVisitor!AST { - void visit(Statement) - { - assert(0); - } - - void visit(ErrorStatement s) - { - visit(cast(Statement)s); - } - - void visit(PeelStatement s) - { - visit(cast(Statement)s); - } - - void visit(ExpStatement s) - { - visit(cast(Statement)s); - } - - void visit(DtorExpStatement s) - { - visit(cast(ExpStatement)s); - } - - void visit(CompileStatement s) - { - visit(cast(Statement)s); - } - - void visit(CompoundStatement s) - { - visit(cast(Statement)s); - } - - void visit(CompoundDeclarationStatement s) - { - visit(cast(CompoundStatement)s); - } + alias visit = ParseTimeVisitor!AST.visit; - void visit(UnrolledLoopStatement s) + void visit(AST.ErrorStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.PeelStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.UnrolledLoopStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.SwitchErrorStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.DebugStatement s) { visit(cast(AST.DebugStatement)s); } + void visit(AST.DtorExpStatement s) { visit(cast(AST.DtorExpStatement)s); } + void visit(AST.ForwardingStatement s) { - visit(cast(Statement)s); - } - - void visit(ScopeStatement s) - { - visit(cast(Statement)s); - } - - void visit(ForwardingStatement s) - { - if (s.statement) - { + if(s.statement) s.statement.accept(this); - } - } - - void visit(WhileStatement s) - { - visit(cast(Statement)s); - } - - void visit(DoStatement s) - { - visit(cast(Statement)s); - } - - void visit(ForStatement s) - { - visit(cast(Statement)s); - } - - void visit(ForeachStatement s) - { - visit(cast(Statement)s); - } - - void visit(ForeachRangeStatement s) - { - visit(cast(Statement)s); - } - - void visit(StaticForeachStatement s) - { - visit(cast(Statement)s); - } - - void visit(IfStatement s) - { - visit(cast(Statement)s); - } - - void visit(ConditionalStatement s) - { - visit(cast(Statement)s); - } - - void visit(PragmaStatement s) - { - visit(cast(Statement)s); - } - - void visit(StaticAssertStatement s) - { - visit(cast(Statement)s); - } - - void visit(SwitchStatement s) - { - visit(cast(Statement)s); - } - - void visit(CaseStatement s) - { - visit(cast(Statement)s); - } - - void visit(CaseRangeStatement s) - { - visit(cast(Statement)s); - } - - void visit(DefaultStatement s) - { - visit(cast(Statement)s); - } - - void visit(GotoDefaultStatement s) - { - visit(cast(Statement)s); - } - - void visit(GotoCaseStatement s) - { - visit(cast(Statement)s); - } - - void visit(SwitchErrorStatement s) - { - visit(cast(Statement)s); - } - - void visit(ReturnStatement s) - { - visit(cast(Statement)s); - } - - void visit(BreakStatement s) - { - visit(cast(Statement)s); - } - - void visit(ContinueStatement s) - { - visit(cast(Statement)s); - } - - void visit(SynchronizedStatement s) - { - visit(cast(Statement)s); - } - - void visit(WithStatement s) - { - visit(cast(Statement)s); - } - - void visit(TryCatchStatement s) - { - visit(cast(Statement)s); - } - - void visit(TryFinallyStatement s) - { - visit(cast(Statement)s); - } - - void visit(OnScopeStatement s) - { - visit(cast(Statement)s); - } - - void visit(ThrowStatement s) - { - visit(cast(Statement)s); - } - - void visit(DebugStatement s) - { - visit(cast(Statement)s); - } - - void visit(GotoStatement s) - { - visit(cast(Statement)s); - } - - void visit(LabelStatement s) - { - visit(cast(Statement)s); - } - - void visit(AsmStatement s) - { - visit(cast(Statement)s); - } - - void visit(CompoundAsmStatement s) - { - visit(cast(CompoundStatement)s); - } - - void visit(ImportStatement s) - { - visit(cast(Statement)s); - } - - void visit(Type) - { - assert(0); - } - - void visit(TypeError t) - { - visit(cast(Type)t); - } - - void visit(TypeNext t) - { - visit(cast(Type)t); - } - - void visit(TypeBasic t) - { - visit(cast(Type)t); - } - - void visit(TypeVector t) - { - visit(cast(Type)t); - } - - void visit(TypeArray t) - { - visit(cast(TypeNext)t); - } - - void visit(TypeSArray t) - { - visit(cast(TypeArray)t); - } - - void visit(TypeDArray t) - { - visit(cast(TypeArray)t); - } - - void visit(TypeAArray t) - { - visit(cast(TypeArray)t); - } - - void visit(TypePointer t) - { - visit(cast(TypeNext)t); - } - - void visit(TypeReference t) - { - visit(cast(TypeNext)t); - } - - void visit(TypeFunction t) - { - visit(cast(TypeNext)t); - } - - void visit(TypeDelegate t) - { - visit(cast(TypeNext)t); - } - - void visit(TypeQualified t) - { - visit(cast(Type)t); - } - - void visit(TypeIdentifier t) - { - visit(cast(TypeQualified)t); - } - - void visit(TypeInstance t) - { - visit(cast(TypeQualified)t); - } - - void visit(TypeTypeof t) - { - visit(cast(TypeQualified)t); - } - - void visit(TypeReturn t) - { - visit(cast(TypeQualified)t); - } - - void visit(TypeStruct t) - { - visit(cast(Type)t); - } - - void visit(TypeEnum t) - { - visit(cast(Type)t); - } - - void visit(TypeClass t) - { - visit(cast(Type)t); - } - - void visit(TypeTuple t) - { - visit(cast(Type)t); - } - - void visit(TypeSlice t) - { - visit(cast(TypeNext)t); - } - - void visit(TypeNull t) - { - visit(cast(Type)t); - } - - void visit(Dsymbol) - { - assert(0); - } - - void visit(StaticAssert s) - { - visit(cast(Dsymbol)s); - } - - void visit(DebugSymbol s) - { - visit(cast(Dsymbol)s); - } - - void visit(VersionSymbol s) - { - visit(cast(Dsymbol)s); - } - - void visit(EnumMember s) - { - visit(cast(VarDeclaration)s); - } - - void visit(Import s) - { - visit(cast(Dsymbol)s); - } - - void visit(OverloadSet s) - { - visit(cast(Dsymbol)s); - } - - void visit(LabelDsymbol s) - { - visit(cast(Dsymbol)s); - } - - void visit(AliasThis s) - { - visit(cast(Dsymbol)s); - } - - void visit(AttribDeclaration s) - { - visit(cast(Dsymbol)s); - } - - void visit(StorageClassDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(DeprecatedDeclaration s) - { - visit(cast(StorageClassDeclaration)s); - } - - void visit(LinkDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(CPPMangleDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(ProtDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(AlignDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(AnonDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(PragmaDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(ConditionalDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(StaticIfDeclaration s) - { - visit(cast(ConditionalDeclaration)s); - } - - void visit(StaticForeachDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(CompileDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(UserAttributeDeclaration s) - { - visit(cast(AttribDeclaration)s); - } - - void visit(ScopeDsymbol s) - { - visit(cast(Dsymbol)s); - } - - void visit(TemplateDeclaration s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(TemplateInstance s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(TemplateMixin s) - { - visit(cast(TemplateInstance)s); - } - - void visit(EnumDeclaration s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(Package s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(Module s) - { - visit(cast(Package)s); - } - - void visit(WithScopeSymbol s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(ArrayScopeSymbol s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(Nspace s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(AggregateDeclaration s) - { - visit(cast(ScopeDsymbol)s); - } - - void visit(StructDeclaration s) - { - visit(cast(AggregateDeclaration)s); - } - - void visit(UnionDeclaration s) - { - visit(cast(StructDeclaration)s); - } - - void visit(ClassDeclaration s) - { - visit(cast(AggregateDeclaration)s); - } - - void visit(InterfaceDeclaration s) - { - visit(cast(ClassDeclaration)s); - } - - void visit(Declaration s) - { - visit(cast(Dsymbol)s); - } - - void visit(TupleDeclaration s) - { - visit(cast(Declaration)s); - } - - void visit(AliasDeclaration s) - { - visit(cast(Declaration)s); - } - - void visit(OverDeclaration s) - { - visit(cast(Declaration)s); - } - - void visit(VarDeclaration s) - { - visit(cast(Declaration)s); - } - - void visit(SymbolDeclaration s) - { - visit(cast(Declaration)s); - } - - void visit(ThisDeclaration s) - { - visit(cast(VarDeclaration)s); - } - - void visit(TypeInfoDeclaration s) - { - visit(cast(VarDeclaration)s); - } - - void visit(TypeInfoStructDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoClassDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoInterfaceDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoPointerDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoArrayDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoStaticArrayDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoAssociativeArrayDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoEnumDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoFunctionDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoDelegateDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoTupleDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoConstDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoInvariantDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoSharedDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoWildDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(TypeInfoVectorDeclaration s) - { - visit(cast(TypeInfoDeclaration)s); - } - - void visit(FuncDeclaration s) - { - visit(cast(Declaration)s); - } - - void visit(FuncAliasDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(FuncLiteralDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(CtorDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(PostBlitDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(DtorDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(StaticCtorDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(SharedStaticCtorDeclaration s) - { - visit(cast(StaticCtorDeclaration)s); - } - - void visit(StaticDtorDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(SharedStaticDtorDeclaration s) - { - visit(cast(StaticDtorDeclaration)s); - } - - void visit(InvariantDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(UnitTestDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(NewDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(DeleteDeclaration s) - { - visit(cast(FuncDeclaration)s); - } - - void visit(Initializer) - { - assert(0); - } - - void visit(VoidInitializer i) - { - visit(cast(Initializer)i); - } - - void visit(ErrorInitializer i) - { - visit(cast(Initializer)i); - } - - void visit(StructInitializer i) - { - visit(cast(Initializer)i); - } - - void visit(ArrayInitializer i) - { - visit(cast(Initializer)i); - } - - void visit(ExpInitializer i) - { - visit(cast(Initializer)i); - } - - void visit(Expression) - { - assert(0); - } - - void visit(IntegerExp e) - { - visit(cast(Expression)e); - } - - void visit(ErrorExp e) - { - visit(cast(Expression)e); - } - - void visit(RealExp e) - { - visit(cast(Expression)e); - } - - void visit(ComplexExp e) - { - visit(cast(Expression)e); - } - - void visit(IdentifierExp e) - { - visit(cast(Expression)e); - } - - void visit(DollarExp e) - { - visit(cast(IdentifierExp)e); - } - - void visit(DsymbolExp e) - { - visit(cast(Expression)e); - } - - void visit(ThisExp e) - { - visit(cast(Expression)e); - } - - void visit(SuperExp e) - { - visit(cast(ThisExp)e); - } - - void visit(NullExp e) - { - visit(cast(Expression)e); - } - - void visit(StringExp e) - { - visit(cast(Expression)e); - } - - void visit(TupleExp e) - { - visit(cast(Expression)e); - } - - void visit(ArrayLiteralExp e) - { - visit(cast(Expression)e); - } - - void visit(AssocArrayLiteralExp e) - { - visit(cast(Expression)e); - } - - void visit(StructLiteralExp e) - { - visit(cast(Expression)e); - } - - void visit(TypeExp e) - { - visit(cast(Expression)e); - } - - void visit(ScopeExp e) - { - visit(cast(Expression)e); - } - - void visit(TemplateExp e) - { - visit(cast(Expression)e); - } - - void visit(NewExp e) - { - visit(cast(Expression)e); - } - - void visit(NewAnonClassExp e) - { - visit(cast(Expression)e); - } - - void visit(SymbolExp e) - { - visit(cast(Expression)e); - } - - void visit(SymOffExp e) - { - visit(cast(SymbolExp)e); - } - - void visit(VarExp e) - { - visit(cast(SymbolExp)e); - } - - void visit(OverExp e) - { - visit(cast(Expression)e); - } - - void visit(FuncExp e) - { - visit(cast(Expression)e); - } - - void visit(DeclarationExp e) - { - visit(cast(Expression)e); - } - - void visit(TypeidExp e) - { - visit(cast(Expression)e); - } - - void visit(TraitsExp e) - { - visit(cast(Expression)e); - } - - void visit(HaltExp e) - { - visit(cast(Expression)e); - } - - void visit(IsExp e) - { - visit(cast(Expression)e); - } - - void visit(UnaExp e) - { - visit(cast(Expression)e); - } - - void visit(BinExp e) - { - visit(cast(Expression)e); - } - - void visit(BinAssignExp e) - { - visit(cast(BinExp)e); - } - - void visit(CompileExp e) - { - visit(cast(UnaExp)e); - } - - void visit(ImportExp e) - { - visit(cast(UnaExp)e); - } - - void visit(AssertExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DotIdExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DotTemplateExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DotVarExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DotTemplateInstanceExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DelegateExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DotTypeExp e) - { - visit(cast(UnaExp)e); - } - - void visit(CallExp e) - { - visit(cast(UnaExp)e); - } - - void visit(AddrExp e) - { - visit(cast(UnaExp)e); - } - - void visit(PtrExp e) - { - visit(cast(UnaExp)e); - } - - void visit(NegExp e) - { - visit(cast(UnaExp)e); - } - - void visit(UAddExp e) - { - visit(cast(UnaExp)e); - } - - void visit(ComExp e) - { - visit(cast(UnaExp)e); - } - - void visit(NotExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DeleteExp e) - { - visit(cast(UnaExp)e); - } - - void visit(CastExp e) - { - visit(cast(UnaExp)e); - } - - void visit(VectorExp e) - { - visit(cast(UnaExp)e); - } - - void visit(SliceExp e) - { - visit(cast(UnaExp)e); - } - - void visit(ArrayLengthExp e) - { - visit(cast(UnaExp)e); - } - - void visit(IntervalExp e) - { - visit(cast(Expression)e); - } - - void visit(DelegatePtrExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DelegateFuncptrExp e) - { - visit(cast(UnaExp)e); - } - - void visit(ArrayExp e) - { - visit(cast(UnaExp)e); - } - - void visit(DotExp e) - { - visit(cast(BinExp)e); - } - - void visit(CommaExp e) - { - visit(cast(BinExp)e); - } - - void visit(IndexExp e) - { - visit(cast(BinExp)e); - } - - void visit(PostExp e) - { - visit(cast(BinExp)e); - } - - void visit(PreExp e) - { - visit(cast(UnaExp)e); - } - - void visit(AssignExp e) - { - visit(cast(BinExp)e); - } - - void visit(ConstructExp e) - { - visit(cast(AssignExp)e); - } - - void visit(BlitExp e) - { - visit(cast(AssignExp)e); - } - - void visit(AddAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(MinAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(MulAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(DivAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(ModAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(AndAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(OrAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(XorAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(PowAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(ShlAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(ShrAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(UshrAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(CatAssignExp e) - { - visit(cast(BinAssignExp)e); - } - - void visit(AddExp e) - { - visit(cast(BinExp)e); - } - - void visit(MinExp e) - { - visit(cast(BinExp)e); - } - - void visit(CatExp e) - { - visit(cast(BinExp)e); - } - - void visit(MulExp e) - { - visit(cast(BinExp)e); - } - - void visit(DivExp e) - { - visit(cast(BinExp)e); - } - - void visit(ModExp e) - { - visit(cast(BinExp)e); - } - - void visit(PowExp e) - { - visit(cast(BinExp)e); - } - - void visit(ShlExp e) - { - visit(cast(BinExp)e); - } - - void visit(ShrExp e) - { - visit(cast(BinExp)e); - } - - void visit(UshrExp e) - { - visit(cast(BinExp)e); - } - - void visit(AndExp e) - { - visit(cast(BinExp)e); - } - - void visit(OrExp e) - { - visit(cast(BinExp)e); - } - - void visit(XorExp e) - { - visit(cast(BinExp)e); - } - - void visit(LogicalExp e) - { - visit(cast(BinExp)e); - } - - void visit(CmpExp e) - { - visit(cast(BinExp)e); - } - - void visit(InExp e) - { - visit(cast(BinExp)e); - } - - void visit(RemoveExp e) - { - visit(cast(BinExp)e); - } - - void visit(EqualExp e) - { - visit(cast(BinExp)e); - } - - void visit(IdentityExp e) - { - visit(cast(BinExp)e); - } - - void visit(CondExp e) - { - visit(cast(BinExp)e); - } - - void visit(DefaultInitExp e) - { - visit(cast(Expression)e); - } - - void visit(FileInitExp e) - { - visit(cast(DefaultInitExp)e); - } - - void visit(LineInitExp e) - { - visit(cast(DefaultInitExp)e); - } - - void visit(ModuleInitExp e) - { - visit(cast(DefaultInitExp)e); - } - - void visit(FuncInitExp e) - { - visit(cast(DefaultInitExp)e); - } - - void visit(PrettyFuncInitExp e) - { - visit(cast(DefaultInitExp)e); - } - - void visit(ClassReferenceExp e) - { - visit(cast(Expression)e); - } - - void visit(VoidInitExp e) - { - visit(cast(Expression)e); - } - - void visit(ThrownExceptionExp e) - { - visit(cast(Expression)e); - } - - void visit(TemplateParameter) - { - assert(0); - } - - void visit(TemplateTypeParameter tp) - { - visit(cast(TemplateParameter)tp); - } - - void visit(TemplateThisParameter tp) - { - visit(cast(TemplateTypeParameter)tp); - } - - void visit(TemplateValueParameter tp) - { - visit(cast(TemplateParameter)tp); - } - - void visit(TemplateAliasParameter tp) - { - visit(cast(TemplateParameter)tp); - } - - void visit(TemplateTupleParameter tp) - { - visit(cast(TemplateParameter)tp); - } - - void visit(Condition) - { - assert(0); - } - - void visit(DVCondition c) - { - visit(cast(Condition)c); - } - - void visit(DebugCondition c) - { - visit(cast(DVCondition)c); - } - - void visit(VersionCondition c) - { - visit(cast(DVCondition)c); - } - - void visit(StaticIfCondition c) - { - visit(cast(Condition)c); - } - - void visit(Parameter) - { - assert(0); } + void visit(AST.OverloadSet s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.LabelDsymbol s) { visit(cast(AST.Dsymbol)s); } + void visit(AST.WithScopeSymbol s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.ArrayScopeSymbol s) { visit(cast(AST.ScopeDsymbol)s); } + void visit(AST.OverDeclaration s) { visit(cast(AST.Declaration)s); } + void visit(AST.SymbolDeclaration s) { visit(cast(AST.SymbolDeclaration)s); } + void visit(AST.ThisDeclaration s) { visit(cast(AST.VarDeclaration)s); } + void visit(AST.TypeInfoDeclaration s) { visit(cast(AST.VarDeclaration)s); } + void visit(AST.TypeInfoStructDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoClassDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoInterfaceDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoPointerDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoArrayDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoStaticArrayDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoAssociativeArrayDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoEnumDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoFunctionDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoDelegateDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoTupleDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoConstDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoInvariantDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoSharedDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoWildDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.TypeInfoVectorDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } + void visit(AST.FuncAliasDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.ErrorInitializer i) { visit(cast(AST.Initializer)i); } + void visit(AST.ErrorExp e) { visit(cast(AST.Expression)e); } + void visit(AST.ComplexExp e) { visit(cast(AST.Expression)e); } + void visit(AST.StructLiteralExp e) { visit(cast(AST.Expression)e); } + void visit(AST.SymOffExp e) { visit(cast(AST.SymbolExp)e); } + void visit(AST.OverExp e) { visit(cast(AST.Expression)e); } + void visit(AST.HaltExp e) { visit(cast(AST.Expression)e); } + void visit(AST.DotTemplateExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DotVarExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DelegateExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DotTypeExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.VectorExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.SliceExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.ArrayLengthExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DelegatePtrExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DelegateFuncptrExp e) { visit(cast(AST.UnaExp)e); } + void visit(AST.DotExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.IndexExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.ConstructExp e) { visit(cast(AST.AssignExp)e); } + void visit(AST.BlitExp e) { visit(cast(AST.AssignExp)e); } + void visit(AST.RemoveExp e) { visit(cast(AST.BinExp)e); } + void visit(AST.ClassReferenceExp e) { visit(cast(AST.Expression)e); } + void visit(AST.VoidInitExp e) { visit(cast(AST.Expression)e); } + void visit(AST.ThrownExceptionExp e) { visit(cast(AST.Expression)e); } } extern (C++) class StoppableVisitor : Visitor { - alias visit = super.visit; + alias visit = Visitor.visit; public: bool stop; diff --git a/src/examples/avg.d b/src/examples/avg.d index 61b5db8be31b..4eb32f5c891f 100644 --- a/src/examples/avg.d +++ b/src/examples/avg.d @@ -16,12 +16,12 @@ import ddmd.identifier; import std.stdio; import std.file; -class FunctionLengthVisitor : TransitiveVisitor +extern(C++) class FunctionLengthVisitor(AST) : TransitiveVisitor!AST { - alias visit = super.visit; + alias visit = TransitiveVisitor!AST.visit; ulong[] lengths; - double getAvgLen(ASTBase.Module m) + double getAvgLen(AST.Module m) { m.accept(this); @@ -32,7 +32,7 @@ class FunctionLengthVisitor : TransitiveVisitor return double(lengths.sum)/lengths.length; } - override void visitFuncBody(ASTBase.FuncDeclaration fd) + override void visitFuncBody(AST.FuncDeclaration fd) { lengths ~= fd.endloc.linnum - fd.loc.linnum; super.visitFuncBody(fd); @@ -58,6 +58,6 @@ void main() p.nextToken(); m.members = p.parseModule(); - scope visitor = new FunctionLengthVisitor(); + scope visitor = new FunctionLengthVisitor!ASTBase(); writeln("Average function length: ", visitor.getAvgLen(m)); } diff --git a/src/examples/impvisitor.d b/src/examples/impvisitor.d index 4164f0dce076..4c34dbb30f84 100644 --- a/src/examples/impvisitor.d +++ b/src/examples/impvisitor.d @@ -1,6 +1,5 @@ module examples.impvisitor; -import ddmd.astbase; import ddmd.permissivevisitor; import ddmd.transitivevisitor; @@ -9,11 +8,11 @@ import ddmd.root.outbuffer; import core.stdc.stdio; -class ImportVisitor2 : TransitiveVisitor +extern(C++) class ImportVisitor2(AST) : TransitiveVisitor!AST { - alias visit = super.visit; + alias visit = TransitiveVisitor!AST.visit; - override void visit(ASTBase.Import imp) + override void visit(AST.Import imp) { if (imp.isstatic) printf("static "); @@ -43,11 +42,11 @@ class ImportVisitor2 : TransitiveVisitor } } -class ImportVisitor : PermissiveVisitor +extern(C++) class ImportVisitor(AST) : PermissiveVisitor!AST { - alias visit = super.visit; + alias visit = PermissiveVisitor!AST.visit; - override void visit(ASTBase.Module m) + override void visit(AST.Module m) { foreach (s; *m.members) { @@ -55,12 +54,12 @@ class ImportVisitor : PermissiveVisitor } } - override void visit(ASTBase.Import i) + override void visit(AST.Import i) { printf("import %s", i.toChars()); } - override void visit(ASTBase.ImportStatement s) + override void visit(AST.ImportStatement s) { foreach (imp; *s.imports) { diff --git a/src/examples/test_parser.d b/src/examples/test_parser.d index 428400ccac6e..02a291c754b5 100644 --- a/src/examples/test_parser.d +++ b/src/examples/test_parser.d @@ -42,7 +42,7 @@ void main() m.members = p.parseModule(); //writeln("Finished parsing. Starting transitive visitor"); - scope vis = new ImportVisitor2(); + scope vis = new ImportVisitor2!ASTBase(); m.accept(vis); //writeln("Finished!"); diff --git a/src/posix.mak b/src/posix.mak index 4ba84f24f3a3..4f45ad52f28d 100644 --- a/src/posix.mak +++ b/src/posix.mak @@ -297,7 +297,7 @@ FRONT_SRCS=$(addsuffix .d, $(addprefix $D/,access aggregate aliasthis apply argt dtemplate dversion escape expression expressionsem func \ hdrgen id impcnvtab imphint init initsem inline inlinecost intrange \ json lib link mars mtype nogc nspace objc opover optimize parse sapply templateparamsem \ - semantic sideeffect statement staticassert target typesem traits visitor \ + semantic sideeffect statement staticassert target typesem traits parsetimevisitor visitor \ typinf utils statement_rewrite_walker statementsem staticcond safe blockexit asttypename printast)) LEXER_SRCS=$(addsuffix .d, $(addprefix $D/, console entity errors globals id identifier lexer tokens utf)) @@ -309,7 +309,7 @@ ROOT_SRCS = $(addsuffix .d,$(addprefix $(ROOT)/,aav array ctfloat file \ filename man outbuffer port response rmem rootobject speller \ stringtable hash)) -PARSER_SRCS=$(addsuffix .d, $(addprefix $D/,parse astbase astbasevisitor transitivevisitor permissivevisitor strictvisitor)) +PARSER_SRCS=$(addsuffix .d, $(addprefix $D/,parse astbase parsetimevisitor transitivevisitor permissivevisitor strictvisitor)) GLUE_OBJS = diff --git a/src/win32.mak b/src/win32.mak index 56bff8af8b64..9a701fb0623d 100644 --- a/src/win32.mak +++ b/src/win32.mak @@ -170,7 +170,7 @@ LEXER_ROOT=$(ROOT)/array.d $(ROOT)/ctfloat.d $(ROOT)/file.d $(ROOT)/filename.d \ $(ROOT)/outbuffer.d $(ROOT)/port.d $(ROOT)/rmem.d $(ROOT)/rootobject.d \ $(ROOT)/stringtable.d $(ROOT)/hash.d -PARSER_SRCS=$D/astbase.d $D/astbasevisitor.d $D/parse.d $D/transitivevisitor.d $D/permissivevisitor.d $D/strictvisitor.d +PARSER_SRCS=$D/astbase.d $D/parsetimevisitor.d $D/parse.d $D/transitivevisitor.d $D/permissivevisitor.d $D/strictvisitor.d GLUE_SRCS=$D/irstate.d $D/toctype.d $D/glue.d $D/gluelayer.d $D/todt.d $D/tocsym.d $D/toir.d $D/dmsc.d \ $D/tocvdebug.d $D/s2ir.d $D/toobj.d $D/e2ir.d $D/objc_glue_stubs.d $D/eh.d $D/iasm.d From 2c6ba3f5578c48ccb6499b200544c38e348e6f49 Mon Sep 17 00:00:00 2001 From: RazvanN7 Date: Tue, 5 Dec 2017 17:21:28 +0200 Subject: [PATCH 2/4] Fix visitor wrong casts --- src/ddmd/apply.d | 2 +- src/ddmd/canthrow.d | 2 +- src/ddmd/delegatize.d | 4 ++-- src/ddmd/dinterpret.d | 2 +- src/ddmd/expression.d | 2 +- src/ddmd/inlinecost.d | 2 +- src/ddmd/nogc.d | 2 +- src/ddmd/parsetimevisitor.d | 3 +-- src/ddmd/sapply.d | 2 +- src/ddmd/sideeffect.d | 4 ++-- src/ddmd/statement.d | 6 +++--- src/ddmd/visitor.d | 6 +++--- 12 files changed, 18 insertions(+), 19 deletions(-) diff --git a/src/ddmd/apply.d b/src/ddmd/apply.d index ffea9eae32db..7e772e9f51b6 100644 --- a/src/ddmd/apply.d +++ b/src/ddmd/apply.d @@ -29,7 +29,7 @@ import ddmd.visitor; */ private extern (C++) final class PostorderExpressionVisitor : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: StoppableVisitor v; diff --git a/src/ddmd/canthrow.d b/src/ddmd/canthrow.d index 8a1c5720677c..5e31695bb57a 100644 --- a/src/ddmd/canthrow.d +++ b/src/ddmd/canthrow.d @@ -39,7 +39,7 @@ extern (C++) bool canThrow(Expression e, FuncDeclaration func, bool mustNotThrow // stop walking if we determine this expression can throw extern (C++) final class CanThrow : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; FuncDeclaration func; bool mustNotThrow; diff --git a/src/ddmd/delegatize.d b/src/ddmd/delegatize.d index 2a464795fc47..1e34cca096d3 100644 --- a/src/ddmd/delegatize.d +++ b/src/ddmd/delegatize.d @@ -88,7 +88,7 @@ private void lambdaSetParent(Expression e, FuncDeclaration fd) { extern (C++) final class LambdaSetParent : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; FuncDeclaration fd; public: @@ -143,7 +143,7 @@ extern (C++) bool lambdaCheckForNestedRef(Expression e, Scope* sc) { extern (C++) final class LambdaCheckForNestedRef : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: Scope* sc; bool result; diff --git a/src/ddmd/dinterpret.d b/src/ddmd/dinterpret.d index b6bd4160ded5..af14ec80d85a 100644 --- a/src/ddmd/dinterpret.d +++ b/src/ddmd/dinterpret.d @@ -262,7 +262,7 @@ struct CompiledCtfeFunction { extern (C++) final class VarWalker : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: CompiledCtfeFunction* ccf; diff --git a/src/ddmd/expression.d b/src/ddmd/expression.d index d9e0b9dd0286..f5d96ef58b43 100644 --- a/src/ddmd/expression.d +++ b/src/ddmd/expression.d @@ -6946,7 +6946,7 @@ extern (C++) final class CondExp : BinExp { extern (C++) final class DtorVisitor : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: Scope* sc; CondExp ce; diff --git a/src/ddmd/inlinecost.d b/src/ddmd/inlinecost.d index 317a82017887..ec8c63155f25 100644 --- a/src/ddmd/inlinecost.d +++ b/src/ddmd/inlinecost.d @@ -285,7 +285,7 @@ public: { extern (C++) final class LambdaInlineCost : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; InlineCostVisitor icv; public: diff --git a/src/ddmd/nogc.d b/src/ddmd/nogc.d index c8dfb14d18ca..6e48fbe49d38 100644 --- a/src/ddmd/nogc.d +++ b/src/ddmd/nogc.d @@ -29,7 +29,7 @@ import ddmd.visitor; */ extern (C++) final class NOGCVisitor : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: FuncDeclaration f; bool err; diff --git a/src/ddmd/parsetimevisitor.d b/src/ddmd/parsetimevisitor.d index 07eb63536137..c9b52ba011e3 100644 --- a/src/ddmd/parsetimevisitor.d +++ b/src/ddmd/parsetimevisitor.d @@ -15,7 +15,6 @@ extern(C++) class ParseTimeVisitor(AST) void visit(AST.Expression) { assert(0); } void visit(AST.TemplateParameter) { assert(0); } void visit(AST.Condition) { assert(0); } -// void visit(AST.StaticForeach) { assert(0); } void visit(AST.Initializer) { assert(0); } //======================================================================================= @@ -69,12 +68,12 @@ extern(C++) class ParseTimeVisitor(AST) void visit(AST.PragmaDeclaration s) { visit(cast(AST.AttribDeclaration)s); } void visit(AST.StorageClassDeclaration s) { visit(cast(AST.AttribDeclaration)s); } void visit(AST.ConditionalDeclaration s) { visit(cast(AST.AttribDeclaration)s); } + void visit(AST.StaticForeachDeclaration s) { visit(cast(AST.AttribDeclaration)s); } //============================================================================================== // Miscellaneous void visit(AST.DeprecatedDeclaration s) { visit(cast(AST.StorageClassDeclaration)s); } void visit(AST.StaticIfDeclaration s) { visit(cast(AST.ConditionalDeclaration)s); } - void visit(AST.StaticForeachDeclaration s) { visit(cast(AST.ConditionalDeclaration)s); } void visit(AST.EnumMember s) { visit(cast(AST.VarDeclaration)s); } void visit(AST.Module s) { visit(cast(AST.Package)s); } void visit(AST.StructDeclaration s) { visit(cast(AST.AggregateDeclaration)s); } diff --git a/src/ddmd/sapply.d b/src/ddmd/sapply.d index 1c3c49c9c65e..278c1e7b574a 100644 --- a/src/ddmd/sapply.d +++ b/src/ddmd/sapply.d @@ -27,7 +27,7 @@ import ddmd.visitor; */ extern (C++) final class PostorderStatementVisitor : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: StoppableVisitor v; diff --git a/src/ddmd/sideeffect.d b/src/ddmd/sideeffect.d index 4c79589f95a8..ded78e5cccdf 100644 --- a/src/ddmd/sideeffect.d +++ b/src/ddmd/sideeffect.d @@ -36,7 +36,7 @@ extern (C++) bool isTrivialExp(Expression e) { extern (C++) final class IsTrivialExp : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: extern (D) this() { @@ -69,7 +69,7 @@ extern (C++) bool hasSideEffect(Expression e) { extern (C++) final class LambdaHasSideEffect : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: extern (D) this() { diff --git a/src/ddmd/statement.d b/src/ddmd/statement.d index 84ca04f98538..a66857ef12e7 100644 --- a/src/ddmd/statement.d +++ b/src/ddmd/statement.d @@ -160,7 +160,7 @@ extern (C++) abstract class Statement : RootObject { extern (C++) final class UsesEH : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: override void visit(Statement s) { @@ -199,7 +199,7 @@ extern (C++) abstract class Statement : RootObject { extern (C++) final class ComeFrom : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: override void visit(Statement s) { @@ -238,7 +238,7 @@ extern (C++) abstract class Statement : RootObject { extern (C++) final class HasCode : StoppableVisitor { - alias visit = StoppableVisitor.visit; + alias visit = super.visit; public: override void visit(Statement s) { diff --git a/src/ddmd/visitor.d b/src/ddmd/visitor.d index 2915b26ccdd1..db68c6f4a9c3 100644 --- a/src/ddmd/visitor.d +++ b/src/ddmd/visitor.d @@ -25,8 +25,8 @@ extern (C++) class GenericVisitor(AST) : ParseTimeVisitor!AST void visit(AST.PeelStatement s) { visit(cast(AST.Statement)s); } void visit(AST.UnrolledLoopStatement s) { visit(cast(AST.Statement)s); } void visit(AST.SwitchErrorStatement s) { visit(cast(AST.Statement)s); } - void visit(AST.DebugStatement s) { visit(cast(AST.DebugStatement)s); } - void visit(AST.DtorExpStatement s) { visit(cast(AST.DtorExpStatement)s); } + void visit(AST.DebugStatement s) { visit(cast(AST.Statement)s); } + void visit(AST.DtorExpStatement s) { visit(cast(AST.ExpStatement)s); } void visit(AST.ForwardingStatement s) { if(s.statement) @@ -37,7 +37,7 @@ extern (C++) class GenericVisitor(AST) : ParseTimeVisitor!AST void visit(AST.WithScopeSymbol s) { visit(cast(AST.ScopeDsymbol)s); } void visit(AST.ArrayScopeSymbol s) { visit(cast(AST.ScopeDsymbol)s); } void visit(AST.OverDeclaration s) { visit(cast(AST.Declaration)s); } - void visit(AST.SymbolDeclaration s) { visit(cast(AST.SymbolDeclaration)s); } + void visit(AST.SymbolDeclaration s) { visit(cast(AST.Declaration)s); } void visit(AST.ThisDeclaration s) { visit(cast(AST.VarDeclaration)s); } void visit(AST.TypeInfoDeclaration s) { visit(cast(AST.VarDeclaration)s); } void visit(AST.TypeInfoStructDeclaration s) { visit(cast(AST.TypeInfoDeclaration)s); } From ebe6aca7e1bb1bc3c18bc838812b57939a5fcff1 Mon Sep 17 00:00:00 2001 From: RazvanN7 Date: Wed, 6 Dec 2017 11:12:31 +0200 Subject: [PATCH 3/4] Fix wrong casts in parsetimevisitor --- src/ddmd/parsetimevisitor.d | 5 +++-- src/ddmd/visitor.d | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/ddmd/parsetimevisitor.d b/src/ddmd/parsetimevisitor.d index c9b52ba011e3..1e569e899edc 100644 --- a/src/ddmd/parsetimevisitor.d +++ b/src/ddmd/parsetimevisitor.d @@ -8,6 +8,7 @@ module ddmd.parsetimevisitor; */ extern(C++) class ParseTimeVisitor(AST) { +public: void visit(AST.Dsymbol) { assert(0); } void visit(AST.Parameter) { assert(0); } void visit(AST.Statement) { assert(0); } @@ -54,8 +55,8 @@ extern(C++) class ParseTimeVisitor(AST) void visit(AST.DeleteDeclaration s) { visit(cast(AST.FuncDeclaration)s); } void visit(AST.StaticCtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } void visit(AST.StaticDtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } - void visit(AST.SharedStaticCtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } - void visit(AST.SharedStaticDtorDeclaration s) { visit(cast(AST.FuncDeclaration)s); } + void visit(AST.SharedStaticCtorDeclaration s) { visit(cast(AST.StaticCtorDeclaration)s); } + void visit(AST.SharedStaticDtorDeclaration s) { visit(cast(AST.StaticDtorDeclaration)s); } // AttribDeclarations void visit(AST.CompileDeclaration s) { visit(cast(AST.AttribDeclaration)s); } diff --git a/src/ddmd/visitor.d b/src/ddmd/visitor.d index db68c6f4a9c3..d9517c76cb2a 100644 --- a/src/ddmd/visitor.d +++ b/src/ddmd/visitor.d @@ -20,7 +20,7 @@ alias Visitor = GenericVisitor!ASTCodegen; extern (C++) class GenericVisitor(AST) : ParseTimeVisitor!AST { alias visit = ParseTimeVisitor!AST.visit; - +public: void visit(AST.ErrorStatement s) { visit(cast(AST.Statement)s); } void visit(AST.PeelStatement s) { visit(cast(AST.Statement)s); } void visit(AST.UnrolledLoopStatement s) { visit(cast(AST.Statement)s); } From 1ee14af58a4dd0e1ea925699b238dec5ec8ba2b2 Mon Sep 17 00:00:00 2001 From: RazvanN7 Date: Wed, 6 Dec 2017 12:29:11 +0200 Subject: [PATCH 4/4] Delete asttypename.d from the makefiles --- src/posix.mak | 2 +- src/win32.mak | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/posix.mak b/src/posix.mak index 4f45ad52f28d..f4e0e9e5f99a 100644 --- a/src/posix.mak +++ b/src/posix.mak @@ -298,7 +298,7 @@ FRONT_SRCS=$(addsuffix .d, $(addprefix $D/,access aggregate aliasthis apply argt hdrgen id impcnvtab imphint init initsem inline inlinecost intrange \ json lib link mars mtype nogc nspace objc opover optimize parse sapply templateparamsem \ semantic sideeffect statement staticassert target typesem traits parsetimevisitor visitor \ - typinf utils statement_rewrite_walker statementsem staticcond safe blockexit asttypename printast)) + typinf utils statement_rewrite_walker statementsem staticcond safe blockexit printast)) LEXER_SRCS=$(addsuffix .d, $(addprefix $D/, console entity errors globals id identifier lexer tokens utf)) diff --git a/src/win32.mak b/src/win32.mak index 9a701fb0623d..2ef7bbbfdd25 100644 --- a/src/win32.mak +++ b/src/win32.mak @@ -159,7 +159,7 @@ FRONT_SRCS=$D/access.d $D/aggregate.d $D/aliasthis.d $D/apply.d $D/argtypes.d $D $D/impcnvtab.d $D/init.d $D/initsem.d $D/inline.d $D/inlinecost.d $D/intrange.d $D/json.d $D/lib.d $D/link.d \ $D/mars.d $D/mtype.d $D/nogc.d $D/nspace.d $D/objc.d $D/opover.d $D/optimize.d $D/parse.d \ $D/sapply.d $D/semantic.d $D/sideeffect.d $D/statement.d $D/staticassert.d $D/target.d \ - $D/safe.d $D/blockexit.d $D/asttypename.d $D/printast.d $D/typesem.d \ + $D/safe.d $D/blockexit.d $D/parsetimevisitor.d $D/printast.d $D/typesem.d \ $D/traits.d $D/utils.d $D/visitor.d $D/libomf.d $D/scanomf.d $D/templateparamsem.d $D/typinf.d \ $D/libmscoff.d $D/scanmscoff.d $D/statement_rewrite_walker.d $D/statementsem.d $D/staticcond.d