transitiveVisitor.d

module core.reflect.transitiveVisitor;

import core.reflect.reflect;
/+
private static immutable ClassDeclaration node
    = cast(immutable ClassDeclaration) nodeFromName("Node", ReflectFlags.Members | ReflectFlags.MemberRecursion);

private bool isBaseOf (const ClassDeclaration Base, const ClassDeclaration C)
    pure nothrow @nogc
{
    auto base = cast() C.base;
    while (base)
    {
        if (base is Base)
        {
            return true;
        }
        base = cast() base.base;
    }
    return false;
}
+/
public abstract class TransitiveVisitor : Visitor
{
  debug (TransitiveVisitor) string log;
  /// We have to keep track of all nodes we have seen
  /// To avoid getting stuck in infinte recursion
  bool [typeof(Node.internalPointer)] seenNodes;

  /// We keep track of the lastSeen so we can bypass the recursive visitation check when handleing baseclasses
  typeof(cast()Node.internalPointer) lastSeen;
/+
  enum body_text = () {
    string result;

    static immutable ClassDeclaration visitor
        = cast(immutable ClassDeclaration)nodeFromName("Visitor", ReflectFlags.Members | ReflectFlags.MemberRecursion);

    static bool isNode(ClassDeclaration C)
    {
        return C is node || node.isBaseOf(C);
    }

    static bool isNodeType(Type T)
    {
        bool result;

        if (auto CT = cast(TypeClass) T)
        {
            result = isNode(CT.sym);
        }
        else
        {
            result = false;
        }

        return result;
    }


    foreach(m;visitor.members)
    {
        if (auto fd = cast(FunctionDeclaration) m)
        {
            auto nodeType = fd.type.parameterTypes[0].type;
            auto cType = cast(TypeClass) nodeType;
            assert(cType, "Nodes are presumed to be classes this one is not?"
                ~ nodeType.toString())
            ;
            auto cDecl = cType.sym;
            assert(isNode(cDecl), cDecl.name ~ " does not have Node as baseClass ... base is " ~ cDecl.base.name);

            result ~= "override void visit(" ~ cDecl.name ~ " node) {\n";

            result ~= "    if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }\n";
            result ~= "    lastSeen = cast()node.internalPointer;\n";
            if (node.isBaseOf(cDecl) && cDecl.base !is node)
            {
                result ~= "    visit(cast(" ~ cDecl.base.name ~ ")node);\n";
            }

            debug (TransitiveVisitor) result ~= "    log ~= \"visiting '" ~ cDecl.name ~ "' \\n\";\n";

            foreach(f; cDecl.fields)
            {
                if (isNodeType(f.type))
                {
                    result ~= "    if (node." ~ f.name ~ ")\n";
                    result ~= "        node." ~ f.name ~ ".accept(this);\n";
                }
                else if (auto ST = cast(TypeSlice) f.type)
                {
                    if (isNodeType(ST.nextOf))
                    {
                        result ~= "    foreach(_e;node." ~ f.name ~ ") {\n";
                        result ~= "        _e.accept(this);\n";
                        result ~= "    }\n";
                    }
                }
            }
            result ~= "}\n\n";
        }
        else assert(0, "all members of Visitor must be functions");
    }
    return result;
  } ();
  pragma(msg, body_text);
  //mixin(body_text);
+/
    override void visit(Node node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = 0; // don't visit the same node anymore we are at the end of the inheritance hierachy
    }

    override void visit(Location loc) { }

    override void visit(Declaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Node)node);
        if (node.location)
            node.location.accept(this);

        foreach(_e;node.attributes) {
            _e.accept(this);
        }
        if (node.parent && !__ctfe)
            node.parent.accept(this);
    }

    override void visit(VariableDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.type)
            node.type.accept(this);
        if (node._init)
            node._init.accept(this);
    }

    override void visit(FunctionDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.type)
            node.type.accept(this);
        foreach(_e;node.parameters) {
            _e.accept(this);
        }
        if (node.fbody)
            node.fbody.accept(this);
        if (node.nextOverload)
            node.nextOverload.accept(this);
    }

    override void visit(EnumDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.type)
            node.type.accept(this);
        foreach(_e;node.members) {
            _e.accept(this);
        }
    }

    override void visit(StructDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(AggregateDeclaration)node);
    }

    override void visit(ClassDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(AggregateDeclaration)node);
        if (node.base)
            node.base.accept(this);
    }

    override void visit(AggregateDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.type)
            node.type.accept(this);
        foreach(_e;node.fields) {
            _e.accept(this);
        }
        foreach(_e;node.members) {
            _e.accept(this);
        }
    }

    override void visit(AliasDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.type)
            node.type.accept(this);
        if (node.decl)
            node.decl.accept(this);
    }

    override void visit(EnumMember node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.value)
            node.value.accept(this);
    }

    override void visit(TemplateDeclaration node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Declaration)node);
        if (node.constraint)
            node.constraint.accept(this);
    }

    override void visit(Expression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Node)node);
        if (node.location)
            node.location.accept(this);
        if (node.type)
            node.type.accept(this);
    }

    override void visit(TypeExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
    }

    override void visit(CallExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.callee)
            node.callee.accept(this);
        foreach(ref _e;node.arguments) {
            _e.accept(this);
        }
    }

    override void visit(TernaryExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.condition)
            node.condition.accept(this);
        if (node.ifTrue)
            node.ifTrue.accept(this);
        if (node.ifFalse)
            node.ifFalse.accept(this);
    }

    override void visit(IndexExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.exp)
            node.exp.accept(this);
        if (node.index)
            node.index.accept(this);
    }

    override void visit(NullExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
    }

    override void visit(VariableExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.var)
            node.var.accept(this);
    }

    override void visit(ParenthesisExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.exp)
            node.exp.accept(this);
    }

    override void visit(DeclarationExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.decl)
            node.decl.accept(this);
    }

    override void visit(BinaryExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.left)
            node.left.accept(this);
        if (node.right)
            node.right.accept(this);
    }

    override void visit(Literal node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
    }

    override void visit(ArrayLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
        foreach(_e;node.elements) {
            _e.accept(this);
        }
    }

    override void visit(DoubleLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
    }

    override void visit(FunctionLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
        foreach(_e;node.parameters) {
            _e.accept(this);
        }
        if (node.fbody)
            node.fbody.accept(this);
    }

    override void visit(IntegerLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
    }

    override void visit(StringLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
    }

    override void visit(StructLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
        foreach(_e;node.elements) {
            if (_e) _e.accept(this);
        }
    }

    override void visit(ClassLiteral node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Literal)node);
        foreach(_e;node.elements) {
            _e.accept(this);
        }
    }

    override void visit(Symbol node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Node)node);
        if (node._scope)
            node._scope.accept(this);
        if (node.parent && !__ctfe)
            node.parent.accept(this);
    }

    override void visit(MemberExpression node)
    {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.exp)
            node.exp.accept(this);
        if (node.member)
            node.member.accept(this);
    }

    override void visit(Import node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Symbol)node);
        if (node.mod)
            node.mod.accept(this);
    }

    override void visit(ScopeSymbol node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Symbol)node);
        foreach(_e;node.members) {
            _e.accept(this);
        }
    }

    override void visit(Package node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(ScopeSymbol)node);
    }

    override void visit(Module node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(ScopeSymbol)node);
        foreach(_e;node.declDefs) {
            _e.accept(this);
        }
        foreach(_e;node.imports) {
            _e.accept(this);
        }
    }

    override void visit(TemplateInstance node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(ScopeSymbol)node);
    }

    override void visit(Type node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Node)node);
        if (node._unqualified)
            node._unqualified.accept(this);
    }

    override void visit(TypeBasic node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
    }

    override void visit(TypeNext node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.nextOf)
            node.nextOf.accept(this);
    }

    override void visit(TypeInstance node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.instance)
            node.instance.accept(this);
    }

    override void visit(TypeIdentifier node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
    }

    override void visit(TypeError node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
    }

    override void visit(TypeTuple node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        foreach(_e;node.types) {
            _e.accept(this);
        }
    }

    override void visit(TypePointer node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(TypeNext)node);
    }

    override void visit(TypeRef node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(TypeNext)node);
    }

    override void visit(TypeSlice node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(TypeNext)node);
    }

    override void visit(TypeEnum node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.sym)
            node.sym.accept(this);
    }

    override void visit(TypeArray node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(TypeNext)node);
    }

    override void visit(TypeAArray node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(TypeNext)node);
        if (node.indexType)
            node.indexType.accept(this);
    }

    override void visit(FunctionType node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.returnType)
            node.returnType.accept(this);
        foreach(_e;node.parameterTypes) {
            _e.accept(this);
        }
    }

    override void visit(TypeDelegate node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(FunctionType)node);
    }

    override void visit(TypeTypeof node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.expr)
            node.expr.accept(this);
    }

    override void visit(TypeClass node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.sym)
            node.sym.accept(this);
    }

    override void visit(TypeStruct node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Type)node);
        if (node.sym)
            node.sym.accept(this);
    }

    override void visit(Statement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Node)node);
        if (node.location)
            node.location.accept(this);
    }

    override void visit(ConditionalStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.stmt)
            node.stmt.accept(this);
    }

    override void visit(LabelStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.stmt)
            node.stmt.accept(this);
    }

    override void visit(ForStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node._init)
            node._init.accept(this);
        if (node.condition)
            node.condition.accept(this);
        if (node.increment)
            node.increment.accept(this);
        if (node._body)
            node._body.accept(this);
    }

    override void visit(DoStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.condition)
            node.condition.accept(this);
        if (node._body)
            node._body.accept(this);
    }

    override void visit(PragmaStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.arguments)
        {
            foreach(ref arg; node.arguments)
                arg.accept(this);
        }
        if (node._body)
            node._body.accept(this);
    }

    override void visit(WithStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.exp)
            node.exp.accept(this);
        if (node._body)
            node._body.accept(this);
        if (node.wthis)
            node.wthis.accept(this);
    }

    override void visit(ThrowStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.exp)
            node.exp.accept(this);
    }

    override void visit(BreakStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
    }

    override void visit(ContinueStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
    }

    override void visit(BlockStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        foreach(_e;node.statements) {
            _e.accept(this);
        }
    }

    override void visit(ReturnStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.exp)
            node.exp.accept(this);
    }

    override void visit(ImportStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        foreach(_e;node.imports) {
            _e.accept(this);
        }
    }

    override void visit(ExpressionStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.exp)
            node.exp.accept(this);
    }

    override void visit(IfStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.condition)
            node.condition.accept(this);
        if (node.ifbranch)
            node.ifbranch.accept(this);
        if (node.elsebranch)
            node.elsebranch.accept(this);
        if (node.assignedVar)
            node.assignedVar.accept(this);
    }

    override void visit(WrappingStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.stmt)
            node.stmt.accept(this);
    }

    override void visit(ScopeStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.stmt)
            node.stmt.accept(this);
    }

    override void visit(TryCatchStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node._body)
            node._body.accept(this);
    }

    override void visit(TryFinallyStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node._body)
            node._body.accept(this);
        if (node.finalbody)
            node.finalbody.accept(this);
    }

    override void visit(GotoStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.target)
            node.target.accept(this);
    }

    override void visit(GotoCaseStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.exp)
            node.exp.accept(this);
        if (node.target)
            node.target.accept(this);
    }

    override void visit(CaseStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.exp)
            node.exp.accept(this);
        if (node.sbody)
            node.sbody.accept(this);
    }

    override void visit(SwitchStatement node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Statement)node);
        if (node.defaultCase)
            node.condition.accept(this);
        foreach(_e;node.cases) {
            _e.accept(this);
        }
        if (node.defaultCase)
            node.defaultCase.accept(this);
    }

    override void visit(FunctionParameter node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        if (node.type)
            node.type.accept(this);
        if (node.defaultArgument)
            node.defaultArgument.accept(this);
    }

    override void visit(Function node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Symbol)node);
        if (node.decl)
            node.decl.accept(this);
    }

    override void visit(Scope node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
    }

    override void visit(ThisExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.var)
            node.var.accept(this);
    }

    override void visit(SliceExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.exp)
            node.exp.accept(this);
        if (node.lowerIndex)
            node.lowerIndex.accept(this);
        if (node.upperIndex)
            node.upperIndex.accept(this);
    }

    override void visit(ArrayLengthExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.array)
            node.array.accept(this);
    }

    override void visit(CastExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.exp)
            node.exp.accept(this);
    }

    override void visit(NewExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
    }

    override void visit(TupleExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        foreach(_e;node.elements) {
            _e.accept(this);
        }
    }

    override void visit(SymbolWrappingExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.sym)
            node.sym.accept(this);
    }

    override void visit(SymbolOffsetExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.var)
            node.var.accept(this);
    }

    override void visit(AddressOfExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
        if (node.exp)
            node.exp.accept(this);
    }

    override void visit(ErrorExpression node) {
        if (node.internalPointer in seenNodes) { if (node.internalPointer != lastSeen) return ; } else { seenNodes [node.internalPointer] = true; }
        lastSeen = cast()node.internalPointer;
        visit(cast(Expression)node);
    }
}