// THIS FILE IS GENERATED
// WARNING! All changes made in this file will be lost!

#ifndef PHP_DEBUG_VISITOR_H_INCLUDED
#define PHP_DEBUG_VISITOR_H_INCLUDED

#include "phpdefaultvisitor.h"

#include "parserexport.h"
#include <kdev-pg-token-stream.h>
#include <QTextStream>
#include <QDebug>

namespace Php
{

class DebugVisitor: public DefaultVisitor
{
public:
    DebugVisitor(TokenStream *str, const QString& content = QString())
        : m_str(str), m_indent(0), m_content(content) {}
    void visitAdditiveExpression(AdditiveExpressionAst *node) override
    {
        printToken(node, QStringLiteral("additiveExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("multiplicativeExpression"), QStringLiteral("expression"));
        if (node->additionalExpressionSequence)
        {
            const KDevPG::ListNode<AdditiveExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("additiveExpressionRest"), QStringLiteral("additionalExpression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitAdditiveExpression(node);
        m_indent--;
    }

    void visitAdditiveExpressionRest(AdditiveExpressionRestAst *node) override
    {
        printToken(node, QStringLiteral("additiveExpressionRest"));
        if (node->expression) printToken(node->expression, QStringLiteral("multiplicativeExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitAdditiveExpressionRest(node);
        m_indent--;
    }

    void visitArrayIndexSpecifier(ArrayIndexSpecifierAst *node) override
    {
        printToken(node, QStringLiteral("arrayIndexSpecifier"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitArrayIndexSpecifier(node);
        m_indent--;
    }

    void visitArrayPairValue(ArrayPairValueAst *node) override
    {
        printToken(node, QStringLiteral("arrayPairValue"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->exprValue) printToken(node->exprValue, QStringLiteral("expr"), QStringLiteral("exprValue"));
        if (node->varValue) printToken(node->varValue, QStringLiteral("variable"), QStringLiteral("varValue"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        ++m_indent;
        DefaultVisitor::visitArrayPairValue(node);
        m_indent--;
    }

    void visitAssignmentExpression(AssignmentExpressionAst *node) override
    {
        printToken(node, QStringLiteral("assignmentExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("conditionalExpression"), QStringLiteral("expression"));
        if (node->assignmentExpressionEqual) printToken(node->assignmentExpressionEqual, QStringLiteral("assignmentExpressionEqual"), QStringLiteral("assignmentExpressionEqual"));
        if (node->assignmentExpression) printToken(node->assignmentExpression, QStringLiteral("assignmentExpression"), QStringLiteral("assignmentExpression"));
        ++m_indent;
        DefaultVisitor::visitAssignmentExpression(node);
        m_indent--;
    }

    void visitAssignmentExpressionCheckIfVariable(AssignmentExpressionCheckIfVariableAst *node) override
    {
        printToken(node, QStringLiteral("assignmentExpressionCheckIfVariable"));
        ++m_indent;
        DefaultVisitor::visitAssignmentExpressionCheckIfVariable(node);
        m_indent--;
    }

    void visitAssignmentExpressionEqual(AssignmentExpressionEqualAst *node) override
    {
        printToken(node, QStringLiteral("assignmentExpressionEqual"));
        if (node->assignmentExpression) printToken(node->assignmentExpression, QStringLiteral("assignmentExpression"), QStringLiteral("assignmentExpression"));
        ++m_indent;
        DefaultVisitor::visitAssignmentExpressionEqual(node);
        m_indent--;
    }

    void visitAssignmentList(AssignmentListAst *node) override
    {
        printToken(node, QStringLiteral("assignmentList"));
        if (node->elementSequence)
        {
            const KDevPG::ListNode<AssignmentListElementAst*> *__it = node->elementSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("assignmentListElement"), QStringLiteral("element[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitAssignmentList(node);
        m_indent--;
    }

    void visitAssignmentListElement(AssignmentListElementAst *node) override
    {
        printToken(node, QStringLiteral("assignmentListElement"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        if (node->assignmentList) printToken(node->assignmentList, QStringLiteral("assignmentList"), QStringLiteral("assignmentList"));
        ++m_indent;
        DefaultVisitor::visitAssignmentListElement(node);
        m_indent--;
    }

    void visitBaseVariable(BaseVariableAst *node) override
    {
        printToken(node, QStringLiteral("baseVariable"));
        if (node->var) printToken(node->var, QStringLiteral("compoundVariableWithSimpleIndirectReference"), QStringLiteral("var"));
        if (node->offsetItemsSequence)
        {
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("dimListItem"), QStringLiteral("offsetItems[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->staticMember) printToken(node->staticMember, QStringLiteral("staticMember"), QStringLiteral("staticMember"));
        ++m_indent;
        DefaultVisitor::visitBaseVariable(node);
        m_indent--;
    }

    void visitBaseVariableWithFunctionCalls(BaseVariableWithFunctionCallsAst *node) override
    {
        printToken(node, QStringLiteral("baseVariableWithFunctionCalls"));
        if (node->functionCall) printToken(node->functionCall, QStringLiteral("functionCall"), QStringLiteral("functionCall"));
        if (node->arrayIndex) printToken(node->arrayIndex, QStringLiteral("arrayIndexSpecifier"), QStringLiteral("arrayIndex"));
        if (node->baseVariable) printToken(node->baseVariable, QStringLiteral("baseVariable"), QStringLiteral("baseVariable"));
        ++m_indent;
        DefaultVisitor::visitBaseVariableWithFunctionCalls(node);
        m_indent--;
    }

    void visitBitAndExpression(BitAndExpressionAst *node) override
    {
        printToken(node, QStringLiteral("bitAndExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<EqualityExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("equalityExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitBitAndExpression(node);
        m_indent--;
    }

    void visitBitOrExpression(BitOrExpressionAst *node) override
    {
        printToken(node, QStringLiteral("bitOrExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<BitXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("bitXorExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitBitOrExpression(node);
        m_indent--;
    }

    void visitBitXorExpression(BitXorExpressionAst *node) override
    {
        printToken(node, QStringLiteral("bitXorExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<BitAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("bitAndExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitBitXorExpression(node);
        m_indent--;
    }

    void visitBooleanAndExpression(BooleanAndExpressionAst *node) override
    {
        printToken(node, QStringLiteral("booleanAndExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<BitOrExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("bitOrExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitBooleanAndExpression(node);
        m_indent--;
    }

    void visitBooleanOrExpression(BooleanOrExpressionAst *node) override
    {
        printToken(node, QStringLiteral("booleanOrExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<BooleanAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("booleanAndExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitBooleanOrExpression(node);
        m_indent--;
    }

    void visitCaseList(CaseListAst *node) override
    {
        printToken(node, QStringLiteral("caseList"));
        if (node->caseItemsSequence)
        {
            const KDevPG::ListNode<Case_itemAst*> *__it = node->caseItemsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("case_item"), QStringLiteral("caseItems[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitCaseList(node);
        m_indent--;
    }

    void visitCase_item(Case_itemAst *node) override
    {
        printToken(node, QStringLiteral("case_item"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitCase_item(node);
        m_indent--;
    }

    void visitCatchItem(CatchItemAst *node) override
    {
        printToken(node, QStringLiteral("catchItem"));
        if (node->catchClassSequence)
        {
            const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->catchClassSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("namespacedIdentifier"), QStringLiteral("catchClass[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->var) printToken(node->var, QStringLiteral("variableIdentifier"), QStringLiteral("var"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitCatchItem(node);
        m_indent--;
    }

    void visitClassBody(ClassBodyAst *node) override
    {
        printToken(node, QStringLiteral("classBody"));
        if (node->classStatementsSequence)
        {
            const KDevPG::ListNode<ClassStatementAst*> *__it = node->classStatementsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("classStatement"), QStringLiteral("classStatements[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitClassBody(node);
        m_indent--;
    }

    void visitClassConstant(ClassConstantAst *node) override
    {
        printToken(node, QStringLiteral("classConstant"));
        ++m_indent;
        DefaultVisitor::visitClassConstant(node);
        m_indent--;
    }

    void visitClassConstantDeclaration(ClassConstantDeclarationAst *node) override
    {
        printToken(node, QStringLiteral("classConstantDeclaration"));
        if (node->identifier) printToken(node->identifier, QStringLiteral("semiReservedIdentifier"), QStringLiteral("identifier"));
        if (node->scalar) printToken(node->scalar, QStringLiteral("expr"), QStringLiteral("scalar"));
        ++m_indent;
        DefaultVisitor::visitClassConstantDeclaration(node);
        m_indent--;
    }

    void visitClassDeclarationStatement(ClassDeclarationStatementAst *node) override
    {
        printToken(node, QStringLiteral("classDeclarationStatement"));
        if (node->modifier) printToken(node->modifier, QStringLiteral("optionalClassModifier"), QStringLiteral("modifier"));
        if (node->className) printToken(node->className, QStringLiteral("identifier"), QStringLiteral("className"));
        if (node->extends) printToken(node->extends, QStringLiteral("classExtends"), QStringLiteral("extends"));
        if (node->implements) printToken(node->implements, QStringLiteral("classImplements"), QStringLiteral("implements"));
        if (node->body) printToken(node->body, QStringLiteral("classBody"), QStringLiteral("body"));
        ++m_indent;
        DefaultVisitor::visitClassDeclarationStatement(node);
        m_indent--;
    }

    void visitClassExtends(ClassExtendsAst *node) override
    {
        printToken(node, QStringLiteral("classExtends"));
        if (node->identifier) printToken(node->identifier, QStringLiteral("namespacedIdentifier"), QStringLiteral("identifier"));
        ++m_indent;
        DefaultVisitor::visitClassExtends(node);
        m_indent--;
    }

    void visitClassImplements(ClassImplementsAst *node) override
    {
        printToken(node, QStringLiteral("classImplements"));
        if (node->implementsSequence)
        {
            const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->implementsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("namespacedIdentifier"), QStringLiteral("implements[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitClassImplements(node);
        m_indent--;
    }

    void visitClassName(ClassNameAst *node) override
    {
        printToken(node, QStringLiteral("className"));
        if (node->identifier) printToken(node->identifier, QStringLiteral("namespacedIdentifier"), QStringLiteral("identifier"));
        ++m_indent;
        DefaultVisitor::visitClassName(node);
        m_indent--;
    }

    void visitClassNameReference(ClassNameReferenceAst *node) override
    {
        printToken(node, QStringLiteral("classNameReference"));
        if (node->className) printToken(node->className, QStringLiteral("className"), QStringLiteral("className"));
        if (node->staticProperty) printToken(node->staticProperty, QStringLiteral("staticProperty"), QStringLiteral("staticProperty"));
        if (node->propertiesSequence)
        {
            const KDevPG::ListNode<ClassPropertyAst*> *__it = node->propertiesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("classProperty"), QStringLiteral("properties[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->baseVariable) printToken(node->baseVariable, QStringLiteral("variableWithoutObjects"), QStringLiteral("baseVariable"));
        ++m_indent;
        DefaultVisitor::visitClassNameReference(node);
        m_indent--;
    }

    void visitClassProperty(ClassPropertyAst *node) override
    {
        printToken(node, QStringLiteral("classProperty"));
        if (node->staticProperty) printToken(node->staticProperty, QStringLiteral("staticProperty"), QStringLiteral("staticProperty"));
        if (node->property) printToken(node->property, QStringLiteral("objectProperty"), QStringLiteral("property"));
        ++m_indent;
        DefaultVisitor::visitClassProperty(node);
        m_indent--;
    }

    void visitClassStatement(ClassStatementAst *node) override
    {
        printToken(node, QStringLiteral("classStatement"));
        if (node->variable) printToken(node->variable, QStringLiteral("classVariableDeclaration"), QStringLiteral("variable"));
        if (node->modifiers) printToken(node->modifiers, QStringLiteral("optionalModifiers"), QStringLiteral("modifiers"));
        if (node->propertyType) printToken(node->propertyType, QStringLiteral("propertyType"), QStringLiteral("propertyType"));
        if (node->methodName) printToken(node->methodName, QStringLiteral("semiReservedIdentifier"), QStringLiteral("methodName"));
        if (node->parameters) printToken(node->parameters, QStringLiteral("parameterList"), QStringLiteral("parameters"));
        if (node->returnType) printToken(node->returnType, QStringLiteral("returnType"), QStringLiteral("returnType"));
        if (node->methodBody) printToken(node->methodBody, QStringLiteral("methodBody"), QStringLiteral("methodBody"));
        if (node->constsSequence)
        {
            const KDevPG::ListNode<ClassConstantDeclarationAst*> *__it = node->constsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("classConstantDeclaration"), QStringLiteral("consts[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->traitsSequence)
        {
            const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->traitsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("namespacedIdentifier"), QStringLiteral("traits[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->imports) printToken(node->imports, QStringLiteral("traitAliasDeclaration"), QStringLiteral("imports"));
        ++m_indent;
        DefaultVisitor::visitClassStatement(node);
        m_indent--;
    }

    void visitClassVariable(ClassVariableAst *node) override
    {
        printToken(node, QStringLiteral("classVariable"));
        if (node->variable) printToken(node->variable, QStringLiteral("variableIdentifier"), QStringLiteral("variable"));
        if (node->value) printToken(node->value, QStringLiteral("staticScalar"), QStringLiteral("value"));
        ++m_indent;
        DefaultVisitor::visitClassVariable(node);
        m_indent--;
    }

    void visitClassVariableDeclaration(ClassVariableDeclarationAst *node) override
    {
        printToken(node, QStringLiteral("classVariableDeclaration"));
        if (node->varsSequence)
        {
            const KDevPG::ListNode<ClassVariableAst*> *__it = node->varsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("classVariable"), QStringLiteral("vars[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitClassVariableDeclaration(node);
        m_indent--;
    }

    void visitClosure(ClosureAst *node) override
    {
        printToken(node, QStringLiteral("closure"));
        if (node->parameters) printToken(node->parameters, QStringLiteral("parameterList"), QStringLiteral("parameters"));
        if (node->lexicalVars) printToken(node->lexicalVars, QStringLiteral("lexicalVarList"), QStringLiteral("lexicalVars"));
        if (node->returnType) printToken(node->returnType, QStringLiteral("returnType"), QStringLiteral("returnType"));
        if (node->functionBody) printToken(node->functionBody, QStringLiteral("innerStatementList"), QStringLiteral("functionBody"));
        ++m_indent;
        DefaultVisitor::visitClosure(node);
        m_indent--;
    }

    void visitCommonScalar(CommonScalarAst *node) override
    {
        printToken(node, QStringLiteral("commonScalar"));
        if (node->stringIndex) printToken(node->stringIndex, QStringLiteral("stringIndexSpecifier"), QStringLiteral("stringIndex"));
        ++m_indent;
        DefaultVisitor::visitCommonScalar(node);
        m_indent--;
    }

    void visitCompoundNamespace(CompoundNamespaceAst *node) override
    {
        printToken(node, QStringLiteral("compoundNamespace"));
        if (node->compoundNamespaceStatementSequence)
        {
            const KDevPG::ListNode<CompoundNamespaceStatementAst*> *__it = node->compoundNamespaceStatementSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("compoundNamespaceStatement"), QStringLiteral("compoundNamespaceStatement[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitCompoundNamespace(node);
        m_indent--;
    }

    void visitCompoundNamespaceStatement(CompoundNamespaceStatementAst *node) override
    {
        printToken(node, QStringLiteral("compoundNamespaceStatement"));
        if (node->useNamespaceSequence)
        {
            const KDevPG::ListNode<InnerUseNamespaceAst*> *__it = node->useNamespaceSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("innerUseNamespace"), QStringLiteral("useNamespace[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitCompoundNamespaceStatement(node);
        m_indent--;
    }

    void visitCompoundVariable(CompoundVariableAst *node) override
    {
        printToken(node, QStringLiteral("compoundVariable"));
        if (node->variable) printToken(node->variable, QStringLiteral("variableIdentifier"), QStringLiteral("variable"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitCompoundVariable(node);
        m_indent--;
    }

    void visitCompoundVariableWithSimpleIndirectReference(CompoundVariableWithSimpleIndirectReferenceAst *node) override
    {
        printToken(node, QStringLiteral("compoundVariableWithSimpleIndirectReference"));
        if (node->indirectVariable) printToken(node->indirectVariable, QStringLiteral("variableIdentifier"), QStringLiteral("indirectVariable"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->variable) printToken(node->variable, QStringLiteral("variableIdentifier"), QStringLiteral("variable"));
        ++m_indent;
        DefaultVisitor::visitCompoundVariableWithSimpleIndirectReference(node);
        m_indent--;
    }

    void visitConditionalExpression(ConditionalExpressionAst *node) override
    {
        printToken(node, QStringLiteral("conditionalExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("nullCoalesceExpression"), QStringLiteral("expression"));
        if (node->ifExpression) printToken(node->ifExpression, QStringLiteral("expr"), QStringLiteral("ifExpression"));
        if (node->elseExpression) printToken(node->elseExpression, QStringLiteral("conditionalExpression"), QStringLiteral("elseExpression"));
        ++m_indent;
        DefaultVisitor::visitConditionalExpression(node);
        m_indent--;
    }

    void visitConstantDeclaration(ConstantDeclarationAst *node) override
    {
        printToken(node, QStringLiteral("constantDeclaration"));
        if (node->identifier) printToken(node->identifier, QStringLiteral("identifier"), QStringLiteral("identifier"));
        if (node->scalar) printToken(node->scalar, QStringLiteral("expr"), QStringLiteral("scalar"));
        ++m_indent;
        DefaultVisitor::visitConstantDeclaration(node);
        m_indent--;
    }

    void visitConstantOrClassConst(ConstantOrClassConstAst *node) override
    {
        printToken(node, QStringLiteral("constantOrClassConst"));
        if (node->constant) printToken(node->constant, QStringLiteral("namespacedIdentifier"), QStringLiteral("constant"));
        if (node->classConstant) printToken(node->classConstant, QStringLiteral("classConstant"), QStringLiteral("classConstant"));
        ++m_indent;
        DefaultVisitor::visitConstantOrClassConst(node);
        m_indent--;
    }

    void visitCtorArguments(CtorArgumentsAst *node) override
    {
        printToken(node, QStringLiteral("ctorArguments"));
        if (node->parameterList) printToken(node->parameterList, QStringLiteral("functionCallParameterList"), QStringLiteral("parameterList"));
        ++m_indent;
        DefaultVisitor::visitCtorArguments(node);
        m_indent--;
    }

    void visitDeclareItem(DeclareItemAst *node) override
    {
        printToken(node, QStringLiteral("declareItem"));
        if (node->scalar) printToken(node->scalar, QStringLiteral("staticScalar"), QStringLiteral("scalar"));
        ++m_indent;
        DefaultVisitor::visitDeclareItem(node);
        m_indent--;
    }

    void visitDeclareStatement(DeclareStatementAst *node) override
    {
        printToken(node, QStringLiteral("declareStatement"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitDeclareStatement(node);
        m_indent--;
    }

    void visitDimListItem(DimListItemAst *node) override
    {
        printToken(node, QStringLiteral("dimListItem"));
        if (node->arrayIndex) printToken(node->arrayIndex, QStringLiteral("arrayIndexSpecifier"), QStringLiteral("arrayIndex"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitDimListItem(node);
        m_indent--;
    }

    void visitElseSingle(ElseSingleAst *node) override
    {
        printToken(node, QStringLiteral("elseSingle"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        ++m_indent;
        DefaultVisitor::visitElseSingle(node);
        m_indent--;
    }

    void visitElseifList(ElseifListAst *node) override
    {
        printToken(node, QStringLiteral("elseifList"));
        if (node->elseifListItemSequence)
        {
            const KDevPG::ListNode<ElseifListItemAst*> *__it = node->elseifListItemSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("elseifListItem"), QStringLiteral("elseifListItem[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitElseifList(node);
        m_indent--;
    }

    void visitElseifListItem(ElseifListItemAst *node) override
    {
        printToken(node, QStringLiteral("elseifListItem"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        ++m_indent;
        DefaultVisitor::visitElseifListItem(node);
        m_indent--;
    }

    void visitEncaps(EncapsAst *node) override
    {
        printToken(node, QStringLiteral("encaps"));
        if (node->var) printToken(node->var, QStringLiteral("encapsVar"), QStringLiteral("var"));
        ++m_indent;
        DefaultVisitor::visitEncaps(node);
        m_indent--;
    }

    void visitEncapsList(EncapsListAst *node) override
    {
        printToken(node, QStringLiteral("encapsList"));
        if (node->encapsSequence)
        {
            const KDevPG::ListNode<EncapsAst*> *__it = node->encapsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("encaps"), QStringLiteral("encaps[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitEncapsList(node);
        m_indent--;
    }

    void visitEncapsVar(EncapsVarAst *node) override
    {
        printToken(node, QStringLiteral("encapsVar"));
        if (node->arrayIndex) printToken(node->arrayIndex, QStringLiteral("arrayIndexSpecifier"), QStringLiteral("arrayIndex"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->variable) printToken(node->variable, QStringLiteral("variableIdentifier"), QStringLiteral("variable"));
        if (node->propertyIdentifier) printToken(node->propertyIdentifier, QStringLiteral("identifier"), QStringLiteral("propertyIdentifier"));
        if (node->offset) printToken(node->offset, QStringLiteral("encapsVarOffset"), QStringLiteral("offset"));
        ++m_indent;
        DefaultVisitor::visitEncapsVar(node);
        m_indent--;
    }

    void visitEncapsVarOffset(EncapsVarOffsetAst *node) override
    {
        printToken(node, QStringLiteral("encapsVarOffset"));
        ++m_indent;
        DefaultVisitor::visitEncapsVarOffset(node);
        m_indent--;
    }

    void visitEqualityExpression(EqualityExpressionAst *node) override
    {
        printToken(node, QStringLiteral("equalityExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("relationalExpression"), QStringLiteral("expression"));
        if (node->additionalExpression) printToken(node->additionalExpression, QStringLiteral("equalityExpressionRest"), QStringLiteral("additionalExpression"));
        ++m_indent;
        DefaultVisitor::visitEqualityExpression(node);
        m_indent--;
    }

    void visitEqualityExpressionRest(EqualityExpressionRestAst *node) override
    {
        printToken(node, QStringLiteral("equalityExpressionRest"));
        if (node->expression) printToken(node->expression, QStringLiteral("relationalExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitEqualityExpressionRest(node);
        m_indent--;
    }

    void visitExpr(ExprAst *node) override
    {
        printToken(node, QStringLiteral("expr"));
        if (node->expression) printToken(node->expression, QStringLiteral("logicalOrExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitExpr(node);
        m_indent--;
    }

    void visitForExpr(ForExprAst *node) override
    {
        printToken(node, QStringLiteral("forExpr"));
        if (node->exprsSequence)
        {
            const KDevPG::ListNode<ExprAst*> *__it = node->exprsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("expr"), QStringLiteral("exprs[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitForExpr(node);
        m_indent--;
    }

    void visitForStatement(ForStatementAst *node) override
    {
        printToken(node, QStringLiteral("forStatement"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitForStatement(node);
        m_indent--;
    }

    void visitForeachStatement(ForeachStatementAst *node) override
    {
        printToken(node, QStringLiteral("foreachStatement"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitForeachStatement(node);
        m_indent--;
    }

    void visitForeachVariable(ForeachVariableAst *node) override
    {
        printToken(node, QStringLiteral("foreachVariable"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        ++m_indent;
        DefaultVisitor::visitForeachVariable(node);
        m_indent--;
    }

    void visitFunctionCall(FunctionCallAst *node) override
    {
        printToken(node, QStringLiteral("functionCall"));
        if (node->stringFunctionNameOrClass) printToken(node->stringFunctionNameOrClass, QStringLiteral("namespacedIdentifier"), QStringLiteral("stringFunctionNameOrClass"));
        if (node->stringParameterList) printToken(node->stringParameterList, QStringLiteral("functionCallParameterList"), QStringLiteral("stringParameterList"));
        if (node->stringFunctionName) printToken(node->stringFunctionName, QStringLiteral("semiReservedIdentifier"), QStringLiteral("stringFunctionName"));
        if (node->varFunctionName) printToken(node->varFunctionName, QStringLiteral("variableWithoutObjects"), QStringLiteral("varFunctionName"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->varParameterList) printToken(node->varParameterList, QStringLiteral("functionCallParameterList"), QStringLiteral("varParameterList"));
        ++m_indent;
        DefaultVisitor::visitFunctionCall(node);
        m_indent--;
    }

    void visitFunctionCallParameterList(FunctionCallParameterListAst *node) override
    {
        printToken(node, QStringLiteral("functionCallParameterList"));
        if (node->parametersSequence)
        {
            const KDevPG::ListNode<FunctionCallParameterListElementAst*> *__it = node->parametersSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("functionCallParameterListElement"), QStringLiteral("parameters[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitFunctionCallParameterList(node);
        m_indent--;
    }

    void visitFunctionCallParameterListElement(FunctionCallParameterListElementAst *node) override
    {
        printToken(node, QStringLiteral("functionCallParameterListElement"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitFunctionCallParameterListElement(node);
        m_indent--;
    }

    void visitFunctionDeclarationStatement(FunctionDeclarationStatementAst *node) override
    {
        printToken(node, QStringLiteral("functionDeclarationStatement"));
        if (node->functionName) printToken(node->functionName, QStringLiteral("identifier"), QStringLiteral("functionName"));
        if (node->parameters) printToken(node->parameters, QStringLiteral("parameterList"), QStringLiteral("parameters"));
        if (node->returnType) printToken(node->returnType, QStringLiteral("returnType"), QStringLiteral("returnType"));
        if (node->functionBody) printToken(node->functionBody, QStringLiteral("innerStatementList"), QStringLiteral("functionBody"));
        ++m_indent;
        DefaultVisitor::visitFunctionDeclarationStatement(node);
        m_indent--;
    }

    void visitGenericTypeHint(GenericTypeHintAst *node) override
    {
        printToken(node, QStringLiteral("genericTypeHint"));
        if (node->genericType) printToken(node->genericType, QStringLiteral("namespacedIdentifier"), QStringLiteral("genericType"));
        ++m_indent;
        DefaultVisitor::visitGenericTypeHint(node);
        m_indent--;
    }

    void visitGlobalVar(GlobalVarAst *node) override
    {
        printToken(node, QStringLiteral("globalVar"));
        if (node->var) printToken(node->var, QStringLiteral("variableIdentifier"), QStringLiteral("var"));
        if (node->dollarVar) printToken(node->dollarVar, QStringLiteral("variable"), QStringLiteral("dollarVar"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitGlobalVar(node);
        m_indent--;
    }

    void visitIdentifier(IdentifierAst *node) override
    {
        printToken(node, QStringLiteral("identifier"));
        ++m_indent;
        DefaultVisitor::visitIdentifier(node);
        m_indent--;
    }

    void visitIifeSyntax(IifeSyntaxAst *node) override
    {
        printToken(node, QStringLiteral("iifeSyntax"));
        if (node->closure) printToken(node->closure, QStringLiteral("closure"), QStringLiteral("closure"));
        if (node->parameterList) printToken(node->parameterList, QStringLiteral("functionCallParameterList"), QStringLiteral("parameterList"));
        if (node->expression) printToken(node->expression, QStringLiteral("expr"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitIifeSyntax(node);
        m_indent--;
    }

    void visitInnerStatementList(InnerStatementListAst *node) override
    {
        printToken(node, QStringLiteral("innerStatementList"));
        if (node->statementsSequence)
        {
            const KDevPG::ListNode<TopStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("topStatement"), QStringLiteral("statements[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitInnerStatementList(node);
        m_indent--;
    }

    void visitInnerUseNamespace(InnerUseNamespaceAst *node) override
    {
        printToken(node, QStringLiteral("innerUseNamespace"));
        if (node->namespaceNameSequence)
        {
            const KDevPG::ListNode<IdentifierAst*> *__it = node->namespaceNameSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("identifier"), QStringLiteral("namespaceName[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->aliasIdentifier) printToken(node->aliasIdentifier, QStringLiteral("identifier"), QStringLiteral("aliasIdentifier"));
        ++m_indent;
        DefaultVisitor::visitInnerUseNamespace(node);
        m_indent--;
    }

    void visitInstantiationAccess(InstantiationAccessAst *node) override
    {
        printToken(node, QStringLiteral("instantiationAccess"));
        if (node->variableProperty) printToken(node->variableProperty, QStringLiteral("variableProperty"), QStringLiteral("variableProperty"));
        ++m_indent;
        DefaultVisitor::visitInstantiationAccess(node);
        m_indent--;
    }

    void visitInterfaceDeclarationStatement(InterfaceDeclarationStatementAst *node) override
    {
        printToken(node, QStringLiteral("interfaceDeclarationStatement"));
        if (node->interfaceName) printToken(node->interfaceName, QStringLiteral("identifier"), QStringLiteral("interfaceName"));
        if (node->extends) printToken(node->extends, QStringLiteral("classImplements"), QStringLiteral("extends"));
        if (node->body) printToken(node->body, QStringLiteral("classBody"), QStringLiteral("body"));
        ++m_indent;
        DefaultVisitor::visitInterfaceDeclarationStatement(node);
        m_indent--;
    }

    void visitLexicalVar(LexicalVarAst *node) override
    {
        printToken(node, QStringLiteral("lexicalVar"));
        if (node->variable) printToken(node->variable, QStringLiteral("variableIdentifier"), QStringLiteral("variable"));
        ++m_indent;
        DefaultVisitor::visitLexicalVar(node);
        m_indent--;
    }

    void visitLexicalVarList(LexicalVarListAst *node) override
    {
        printToken(node, QStringLiteral("lexicalVarList"));
        if (node->lexicalVarsSequence)
        {
            const KDevPG::ListNode<LexicalVarAst*> *__it = node->lexicalVarsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("lexicalVar"), QStringLiteral("lexicalVars[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitLexicalVarList(node);
        m_indent--;
    }

    void visitLogicalAndExpression(LogicalAndExpressionAst *node) override
    {
        printToken(node, QStringLiteral("logicalAndExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<PrintExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("printExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitLogicalAndExpression(node);
        m_indent--;
    }

    void visitLogicalOrExpression(LogicalOrExpressionAst *node) override
    {
        printToken(node, QStringLiteral("logicalOrExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<LogicalXorExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("logicalXorExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitLogicalOrExpression(node);
        m_indent--;
    }

    void visitLogicalXorExpression(LogicalXorExpressionAst *node) override
    {
        printToken(node, QStringLiteral("logicalXorExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<LogicalAndExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("logicalAndExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitLogicalXorExpression(node);
        m_indent--;
    }

    void visitMethodBody(MethodBodyAst *node) override
    {
        printToken(node, QStringLiteral("methodBody"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitMethodBody(node);
        m_indent--;
    }

    void visitMultiplicativeExpression(MultiplicativeExpressionAst *node) override
    {
        printToken(node, QStringLiteral("multiplicativeExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("unaryExpression"), QStringLiteral("expression"));
        if (node->additionalExpressionSequence)
        {
            const KDevPG::ListNode<MultiplicativeExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("multiplicativeExpressionRest"), QStringLiteral("additionalExpression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitMultiplicativeExpression(node);
        m_indent--;
    }

    void visitMultiplicativeExpressionRest(MultiplicativeExpressionRestAst *node) override
    {
        printToken(node, QStringLiteral("multiplicativeExpressionRest"));
        if (node->expression) printToken(node->expression, QStringLiteral("unaryExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitMultiplicativeExpressionRest(node);
        m_indent--;
    }

    void visitNamespaceDeclarationStatement(NamespaceDeclarationStatementAst *node) override
    {
        printToken(node, QStringLiteral("namespaceDeclarationStatement"));
        if (node->namespaceNameSequence)
        {
            const KDevPG::ListNode<IdentifierAst*> *__it = node->namespaceNameSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("identifier"), QStringLiteral("namespaceName[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->body) printToken(node->body, QStringLiteral("innerStatementList"), QStringLiteral("body"));
        ++m_indent;
        DefaultVisitor::visitNamespaceDeclarationStatement(node);
        m_indent--;
    }

    void visitNamespacedIdentifier(NamespacedIdentifierAst *node) override
    {
        printToken(node, QStringLiteral("namespacedIdentifier"));
        if (node->namespaceNameSequence)
        {
            const KDevPG::ListNode<IdentifierAst*> *__it = node->namespaceNameSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("identifier"), QStringLiteral("namespaceName[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitNamespacedIdentifier(node);
        m_indent--;
    }

    void visitNamespacedIdentifierBeforeGroupedNamespace(NamespacedIdentifierBeforeGroupedNamespaceAst *node) override
    {
        printToken(node, QStringLiteral("namespacedIdentifierBeforeGroupedNamespace"));
        if (node->namespaceNameSequence)
        {
            const KDevPG::ListNode<IdentifierAst*> *__it = node->namespaceNameSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("identifier"), QStringLiteral("namespaceName[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitNamespacedIdentifierBeforeGroupedNamespace(node);
        m_indent--;
    }

    void visitNewElseSingle(NewElseSingleAst *node) override
    {
        printToken(node, QStringLiteral("newElseSingle"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitNewElseSingle(node);
        m_indent--;
    }

    void visitNewElseifList(NewElseifListAst *node) override
    {
        printToken(node, QStringLiteral("newElseifList"));
        if (node->newElseifListItemSequence)
        {
            const KDevPG::ListNode<NewelseifListItemAst*> *__it = node->newElseifListItemSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("newelseifListItem"), QStringLiteral("newElseifListItem[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitNewElseifList(node);
        m_indent--;
    }

    void visitNewelseifListItem(NewelseifListItemAst *node) override
    {
        printToken(node, QStringLiteral("newelseifListItem"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitNewelseifListItem(node);
        m_indent--;
    }

    void visitNullCoalesceExpression(NullCoalesceExpressionAst *node) override
    {
        printToken(node, QStringLiteral("nullCoalesceExpression"));
        if (node->expressionSequence)
        {
            const KDevPG::ListNode<BooleanOrExpressionAst*> *__it = node->expressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("booleanOrExpression"), QStringLiteral("expression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitNullCoalesceExpression(node);
        m_indent--;
    }

    void visitObjectDimList(ObjectDimListAst *node) override
    {
        printToken(node, QStringLiteral("objectDimList"));
        if (node->variableName) printToken(node->variableName, QStringLiteral("variableName"), QStringLiteral("variableName"));
        if (node->offsetItemsSequence)
        {
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("dimListItem"), QStringLiteral("offsetItems[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitObjectDimList(node);
        m_indent--;
    }

    void visitObjectOperator(ObjectOperatorAst *node) override
    {
        printToken(node, QStringLiteral("objectOperator"));
        ++m_indent;
        DefaultVisitor::visitObjectOperator(node);
        m_indent--;
    }

    void visitObjectProperty(ObjectPropertyAst *node) override
    {
        printToken(node, QStringLiteral("objectProperty"));
        if (node->objectDimList) printToken(node->objectDimList, QStringLiteral("objectDimList"), QStringLiteral("objectDimList"));
        if (node->variableWithoutObjects) printToken(node->variableWithoutObjects, QStringLiteral("variableWithoutObjects"), QStringLiteral("variableWithoutObjects"));
        ++m_indent;
        DefaultVisitor::visitObjectProperty(node);
        m_indent--;
    }

    void visitOptionalClassModifier(OptionalClassModifierAst *node) override
    {
        printToken(node, QStringLiteral("optionalClassModifier"));
        ++m_indent;
        DefaultVisitor::visitOptionalClassModifier(node);
        m_indent--;
    }

    void visitOptionalModifiers(OptionalModifiersAst *node) override
    {
        printToken(node, QStringLiteral("optionalModifiers"));
        ++m_indent;
        DefaultVisitor::visitOptionalModifiers(node);
        m_indent--;
    }

    void visitOuterTopStatement(OuterTopStatementAst *node) override
    {
        printToken(node, QStringLiteral("outerTopStatement"));
        if (node->namespaceDeclaration) printToken(node->namespaceDeclaration, QStringLiteral("namespaceDeclarationStatement"), QStringLiteral("namespaceDeclaration"));
        if (node->statement) printToken(node->statement, QStringLiteral("topStatement"), QStringLiteral("statement"));
        ++m_indent;
        DefaultVisitor::visitOuterTopStatement(node);
        m_indent--;
    }

    void visitParameter(ParameterAst *node) override
    {
        printToken(node, QStringLiteral("parameter"));
        if (node->parameterType) printToken(node->parameterType, QStringLiteral("parameterType"), QStringLiteral("parameterType"));
        if (node->variable) printToken(node->variable, QStringLiteral("variableIdentifier"), QStringLiteral("variable"));
        if (node->defaultValue) printToken(node->defaultValue, QStringLiteral("expr"), QStringLiteral("defaultValue"));
        ++m_indent;
        DefaultVisitor::visitParameter(node);
        m_indent--;
    }

    void visitParameterList(ParameterListAst *node) override
    {
        printToken(node, QStringLiteral("parameterList"));
        if (node->parametersSequence)
        {
            const KDevPG::ListNode<ParameterAst*> *__it = node->parametersSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("parameter"), QStringLiteral("parameters[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitParameterList(node);
        m_indent--;
    }

    void visitParameterType(ParameterTypeAst *node) override
    {
        printToken(node, QStringLiteral("parameterType"));
        if (node->typehint) printToken(node->typehint, QStringLiteral("genericTypeHint"), QStringLiteral("typehint"));
        ++m_indent;
        DefaultVisitor::visitParameterType(node);
        m_indent--;
    }

    void visitPostprefixOperator(PostprefixOperatorAst *node) override
    {
        printToken(node, QStringLiteral("postprefixOperator"));
        ++m_indent;
        DefaultVisitor::visitPostprefixOperator(node);
        m_indent--;
    }

    void visitPrintExpression(PrintExpressionAst *node) override
    {
        printToken(node, QStringLiteral("printExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("assignmentExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitPrintExpression(node);
        m_indent--;
    }

    void visitPropertyType(PropertyTypeAst *node) override
    {
        printToken(node, QStringLiteral("propertyType"));
        if (node->typehint) printToken(node->typehint, QStringLiteral("propertyTypeHint"), QStringLiteral("typehint"));
        ++m_indent;
        DefaultVisitor::visitPropertyType(node);
        m_indent--;
    }

    void visitPropertyTypeHint(PropertyTypeHintAst *node) override
    {
        printToken(node, QStringLiteral("propertyTypeHint"));
        if (node->genericType) printToken(node->genericType, QStringLiteral("namespacedIdentifier"), QStringLiteral("genericType"));
        ++m_indent;
        DefaultVisitor::visitPropertyTypeHint(node);
        m_indent--;
    }

    void visitRelationalExpression(RelationalExpressionAst *node) override
    {
        printToken(node, QStringLiteral("relationalExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("shiftExpression"), QStringLiteral("expression"));
        if (node->additionalExpression) printToken(node->additionalExpression, QStringLiteral("relationalExpressionRest"), QStringLiteral("additionalExpression"));
        if (node->instanceofType) printToken(node->instanceofType, QStringLiteral("classNameReference"), QStringLiteral("instanceofType"));
        ++m_indent;
        DefaultVisitor::visitRelationalExpression(node);
        m_indent--;
    }

    void visitRelationalExpressionRest(RelationalExpressionRestAst *node) override
    {
        printToken(node, QStringLiteral("relationalExpressionRest"));
        if (node->expression) printToken(node->expression, QStringLiteral("shiftExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitRelationalExpressionRest(node);
        m_indent--;
    }

    void visitReservedNonModifierIdentifier(ReservedNonModifierIdentifierAst *node) override
    {
        printToken(node, QStringLiteral("reservedNonModifierIdentifier"));
        ++m_indent;
        DefaultVisitor::visitReservedNonModifierIdentifier(node);
        m_indent--;
    }

    void visitReservedNonModifiers(ReservedNonModifiersAst *node) override
    {
        printToken(node, QStringLiteral("reservedNonModifiers"));
        ++m_indent;
        DefaultVisitor::visitReservedNonModifiers(node);
        m_indent--;
    }

    void visitReturnType(ReturnTypeAst *node) override
    {
        printToken(node, QStringLiteral("returnType"));
        if (node->typehint) printToken(node->typehint, QStringLiteral("genericTypeHint"), QStringLiteral("typehint"));
        ++m_indent;
        DefaultVisitor::visitReturnType(node);
        m_indent--;
    }

    void visitScalar(ScalarAst *node) override
    {
        printToken(node, QStringLiteral("scalar"));
        if (node->commonScalar) printToken(node->commonScalar, QStringLiteral("commonScalar"), QStringLiteral("commonScalar"));
        if (node->constantOrClassConst) printToken(node->constantOrClassConst, QStringLiteral("constantOrClassConst"), QStringLiteral("constantOrClassConst"));
        if (node->offsetItemSequence)
        {
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("dimListItem"), QStringLiteral("offsetItem[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->encapsList) printToken(node->encapsList, QStringLiteral("encapsList"), QStringLiteral("encapsList"));
        if (node->stringIndex) printToken(node->stringIndex, QStringLiteral("stringIndexSpecifier"), QStringLiteral("stringIndex"));
        ++m_indent;
        DefaultVisitor::visitScalar(node);
        m_indent--;
    }

    void visitSemiReserved(SemiReservedAst *node) override
    {
        printToken(node, QStringLiteral("semiReserved"));
        ++m_indent;
        DefaultVisitor::visitSemiReserved(node);
        m_indent--;
    }

    void visitSemiReservedIdentifier(SemiReservedIdentifierAst *node) override
    {
        printToken(node, QStringLiteral("semiReservedIdentifier"));
        ++m_indent;
        DefaultVisitor::visitSemiReservedIdentifier(node);
        m_indent--;
    }

    void visitSemicolonOrCloseTag(SemicolonOrCloseTagAst *node) override
    {
        printToken(node, QStringLiteral("semicolonOrCloseTag"));
        ++m_indent;
        DefaultVisitor::visitSemicolonOrCloseTag(node);
        m_indent--;
    }

    void visitShiftExpression(ShiftExpressionAst *node) override
    {
        printToken(node, QStringLiteral("shiftExpression"));
        if (node->expression) printToken(node->expression, QStringLiteral("additiveExpression"), QStringLiteral("expression"));
        if (node->additionalExpressionSequence)
        {
            const KDevPG::ListNode<ShiftExpressionRestAst*> *__it = node->additionalExpressionSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("shiftExpressionRest"), QStringLiteral("additionalExpression[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitShiftExpression(node);
        m_indent--;
    }

    void visitShiftExpressionRest(ShiftExpressionRestAst *node) override
    {
        printToken(node, QStringLiteral("shiftExpressionRest"));
        if (node->expression) printToken(node->expression, QStringLiteral("additiveExpression"), QStringLiteral("expression"));
        ++m_indent;
        DefaultVisitor::visitShiftExpressionRest(node);
        m_indent--;
    }

    void visitStart(StartAst *node) override
    {
        printToken(node, QStringLiteral("start"));
        if (node->statementsSequence)
        {
            const KDevPG::ListNode<OuterTopStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("outerTopStatement"), QStringLiteral("statements[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitStart(node);
        m_indent--;
    }

    void visitStatement(StatementAst *node) override
    {
        printToken(node, QStringLiteral("statement"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        if (node->ifExpr) printToken(node->ifExpr, QStringLiteral("expr"), QStringLiteral("ifExpr"));
        if (node->ifStatement) printToken(node->ifStatement, QStringLiteral("statement"), QStringLiteral("ifStatement"));
        if (node->elseifList) printToken(node->elseifList, QStringLiteral("elseifList"), QStringLiteral("elseifList"));
        if (node->elseSingle) printToken(node->elseSingle, QStringLiteral("elseSingle"), QStringLiteral("elseSingle"));
        if (node->whileExpr) printToken(node->whileExpr, QStringLiteral("expr"), QStringLiteral("whileExpr"));
        if (node->whileStatement) printToken(node->whileStatement, QStringLiteral("whileStatement"), QStringLiteral("whileStatement"));
        if (node->forExpr1) printToken(node->forExpr1, QStringLiteral("forExpr"), QStringLiteral("forExpr1"));
        if (node->forExpr2) printToken(node->forExpr2, QStringLiteral("forExpr"), QStringLiteral("forExpr2"));
        if (node->forExpr3) printToken(node->forExpr3, QStringLiteral("forExpr"), QStringLiteral("forExpr3"));
        if (node->forStatement) printToken(node->forStatement, QStringLiteral("forStatement"), QStringLiteral("forStatement"));
        if (node->swtichExpr) printToken(node->swtichExpr, QStringLiteral("expr"), QStringLiteral("swtichExpr"));
        if (node->switchCaseList) printToken(node->switchCaseList, QStringLiteral("switchCaseList"), QStringLiteral("switchCaseList"));
        if (node->foreachVar) printToken(node->foreachVar, QStringLiteral("variable"), QStringLiteral("foreachVar"));
        if (node->foreachVarAsVar) printToken(node->foreachVarAsVar, QStringLiteral("foreachVariable"), QStringLiteral("foreachVarAsVar"));
        if (node->foreachExpr) printToken(node->foreachExpr, QStringLiteral("expr"), QStringLiteral("foreachExpr"));
        if (node->foreachExprAsVar) printToken(node->foreachExprAsVar, QStringLiteral("variable"), QStringLiteral("foreachExprAsVar"));
        if (node->foreachVariable) printToken(node->foreachVariable, QStringLiteral("foreachVariable"), QStringLiteral("foreachVariable"));
        if (node->foreachStatement) printToken(node->foreachStatement, QStringLiteral("foreachStatement"), QStringLiteral("foreachStatement"));
        if (node->declareItem) printToken(node->declareItem, QStringLiteral("declareItem"), QStringLiteral("declareItem"));
        if (node->catchesSequence)
        {
            const KDevPG::ListNode<CatchItemAst*> *__it = node->catchesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("catchItem"), QStringLiteral("catches[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->finallyBody) printToken(node->finallyBody, QStringLiteral("innerStatementList"), QStringLiteral("finallyBody"));
        if (node->unsetVariablesSequence)
        {
            const KDevPG::ListNode<VariableAst*> *__it = node->unsetVariablesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("variable"), QStringLiteral("unsetVariables[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        if (node->doStatement) printToken(node->doStatement, QStringLiteral("statement"), QStringLiteral("doStatement"));
        if (node->breakExpr) printToken(node->breakExpr, QStringLiteral("expr"), QStringLiteral("breakExpr"));
        if (node->continueExpr) printToken(node->continueExpr, QStringLiteral("expr"), QStringLiteral("continueExpr"));
        if (node->returnExpr) printToken(node->returnExpr, QStringLiteral("expr"), QStringLiteral("returnExpr"));
        if (node->globalVarsSequence)
        {
            const KDevPG::ListNode<GlobalVarAst*> *__it = node->globalVarsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("globalVar"), QStringLiteral("globalVars[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->staticVarsSequence)
        {
            const KDevPG::ListNode<StaticVarAst*> *__it = node->staticVarsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("staticVar"), QStringLiteral("staticVars[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->echoExprsSequence)
        {
            const KDevPG::ListNode<ExprAst*> *__it = node->echoExprsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("expr"), QStringLiteral("echoExprs[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->throwExpr) printToken(node->throwExpr, QStringLiteral("expr"), QStringLiteral("throwExpr"));
        if (node->constsSequence)
        {
            const KDevPG::ListNode<ConstantDeclarationAst*> *__it = node->constsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("constantDeclaration"), QStringLiteral("consts[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->useStatement) printToken(node->useStatement, QStringLiteral("useStatement"), QStringLiteral("useStatement"));
        ++m_indent;
        DefaultVisitor::visitStatement(node);
        m_indent--;
    }

    void visitStaticArrayPairValue(StaticArrayPairValueAst *node) override
    {
        printToken(node, QStringLiteral("staticArrayPairValue"));
        if (node->val1Sequence)
        {
            const KDevPG::ListNode<StaticScalarAst*> *__it = node->val1Sequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("staticScalar"), QStringLiteral("val1[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->val2Sequence)
        {
            const KDevPG::ListNode<StaticScalarAst*> *__it = node->val2Sequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("staticScalar"), QStringLiteral("val2[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitStaticArrayPairValue(node);
        m_indent--;
    }

    void visitStaticMember(StaticMemberAst *node) override
    {
        printToken(node, QStringLiteral("staticMember"));
        if (node->className) printToken(node->className, QStringLiteral("namespacedIdentifier"), QStringLiteral("className"));
        if (node->staticProperty) printToken(node->staticProperty, QStringLiteral("staticProperty"), QStringLiteral("staticProperty"));
        ++m_indent;
        DefaultVisitor::visitStaticMember(node);
        m_indent--;
    }

    void visitStaticProperty(StaticPropertyAst *node) override
    {
        printToken(node, QStringLiteral("staticProperty"));
        if (node->staticProperty) printToken(node->staticProperty, QStringLiteral("compoundVariableWithSimpleIndirectReference"), QStringLiteral("staticProperty"));
        if (node->offsetItemsSequence)
        {
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("dimListItem"), QStringLiteral("offsetItems[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitStaticProperty(node);
        m_indent--;
    }

    void visitStaticScalar(StaticScalarAst *node) override
    {
        printToken(node, QStringLiteral("staticScalar"));
        if (node->value) printToken(node->value, QStringLiteral("commonScalar"), QStringLiteral("value"));
        if (node->constantOrClassConst) printToken(node->constantOrClassConst, QStringLiteral("constantOrClassConst"), QStringLiteral("constantOrClassConst"));
        if (node->plusValue) printToken(node->plusValue, QStringLiteral("staticScalar"), QStringLiteral("plusValue"));
        if (node->minusValue) printToken(node->minusValue, QStringLiteral("staticScalar"), QStringLiteral("minusValue"));
        if (node->arrayValuesSequence)
        {
            const KDevPG::ListNode<StaticArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("staticArrayPairValue"), QStringLiteral("arrayValues[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitStaticScalar(node);
        m_indent--;
    }

    void visitStaticVar(StaticVarAst *node) override
    {
        printToken(node, QStringLiteral("staticVar"));
        if (node->var) printToken(node->var, QStringLiteral("variableIdentifier"), QStringLiteral("var"));
        if (node->value) printToken(node->value, QStringLiteral("staticScalar"), QStringLiteral("value"));
        ++m_indent;
        DefaultVisitor::visitStaticVar(node);
        m_indent--;
    }

    void visitStringIndexSpecifier(StringIndexSpecifierAst *node) override
    {
        printToken(node, QStringLiteral("stringIndexSpecifier"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitStringIndexSpecifier(node);
        m_indent--;
    }

    void visitSwitchCaseList(SwitchCaseListAst *node) override
    {
        printToken(node, QStringLiteral("switchCaseList"));
        if (node->caseList) printToken(node->caseList, QStringLiteral("caseList"), QStringLiteral("caseList"));
        ++m_indent;
        DefaultVisitor::visitSwitchCaseList(node);
        m_indent--;
    }

    void visitTopStatement(TopStatementAst *node) override
    {
        printToken(node, QStringLiteral("topStatement"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        if (node->functionDeclaration) printToken(node->functionDeclaration, QStringLiteral("functionDeclarationStatement"), QStringLiteral("functionDeclaration"));
        if (node->classDeclaration) printToken(node->classDeclaration, QStringLiteral("classDeclarationStatement"), QStringLiteral("classDeclaration"));
        if (node->traitDeclaration) printToken(node->traitDeclaration, QStringLiteral("traitDeclarationStatement"), QStringLiteral("traitDeclaration"));
        if (node->interfaceDeclaration) printToken(node->interfaceDeclaration, QStringLiteral("interfaceDeclarationStatement"), QStringLiteral("interfaceDeclaration"));
        ++m_indent;
        DefaultVisitor::visitTopStatement(node);
        m_indent--;
    }

    void visitTraitAliasDeclaration(TraitAliasDeclarationAst *node) override
    {
        printToken(node, QStringLiteral("traitAliasDeclaration"));
        if (node->statementsSequence)
        {
            const KDevPG::ListNode<TraitAliasStatementAst*> *__it = node->statementsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("traitAliasStatement"), QStringLiteral("statements[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitTraitAliasDeclaration(node);
        m_indent--;
    }

    void visitTraitAliasIdentifier(TraitAliasIdentifierAst *node) override
    {
        printToken(node, QStringLiteral("traitAliasIdentifier"));
        if (node->identifier) printToken(node->identifier, QStringLiteral("namespacedIdentifier"), QStringLiteral("identifier"));
        if (node->methodIdentifier) printToken(node->methodIdentifier, QStringLiteral("semiReservedIdentifier"), QStringLiteral("methodIdentifier"));
        ++m_indent;
        DefaultVisitor::visitTraitAliasIdentifier(node);
        m_indent--;
    }

    void visitTraitAliasStatement(TraitAliasStatementAst *node) override
    {
        printToken(node, QStringLiteral("traitAliasStatement"));
        if (node->importIdentifier) printToken(node->importIdentifier, QStringLiteral("traitAliasIdentifier"), QStringLiteral("importIdentifier"));
        if (node->modifiers) printToken(node->modifiers, QStringLiteral("traitVisibilityModifiers"), QStringLiteral("modifiers"));
        if (node->aliasNonModifierIdentifier) printToken(node->aliasNonModifierIdentifier, QStringLiteral("reservedNonModifierIdentifier"), QStringLiteral("aliasNonModifierIdentifier"));
        if (node->aliasIdentifier) printToken(node->aliasIdentifier, QStringLiteral("semiReservedIdentifier"), QStringLiteral("aliasIdentifier"));
        if (node->conflictIdentifierSequence)
        {
            const KDevPG::ListNode<NamespacedIdentifierAst*> *__it = node->conflictIdentifierSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("namespacedIdentifier"), QStringLiteral("conflictIdentifier[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitTraitAliasStatement(node);
        m_indent--;
    }

    void visitTraitDeclarationStatement(TraitDeclarationStatementAst *node) override
    {
        printToken(node, QStringLiteral("traitDeclarationStatement"));
        if (node->traitName) printToken(node->traitName, QStringLiteral("identifier"), QStringLiteral("traitName"));
        if (node->body) printToken(node->body, QStringLiteral("classBody"), QStringLiteral("body"));
        ++m_indent;
        DefaultVisitor::visitTraitDeclarationStatement(node);
        m_indent--;
    }

    void visitTraitVisibilityModifiers(TraitVisibilityModifiersAst *node) override
    {
        printToken(node, QStringLiteral("traitVisibilityModifiers"));
        ++m_indent;
        DefaultVisitor::visitTraitVisibilityModifiers(node);
        m_indent--;
    }

    void visitUnaryExpression(UnaryExpressionAst *node) override
    {
        printToken(node, QStringLiteral("unaryExpression"));
        if (node->unaryExpression) printToken(node->unaryExpression, QStringLiteral("unaryExpression"), QStringLiteral("unaryExpression"));
        if (node->assignmentList) printToken(node->assignmentList, QStringLiteral("assignmentList"), QStringLiteral("assignmentList"));
        if (node->expression) printToken(node->expression, QStringLiteral("expr"), QStringLiteral("expression"));
        if (node->includeExpression) printToken(node->includeExpression, QStringLiteral("unaryExpression"), QStringLiteral("includeExpression"));
        if (node->unaryExpressionNotPlusminus) printToken(node->unaryExpressionNotPlusminus, QStringLiteral("unaryExpressionNotPlusminus"), QStringLiteral("unaryExpressionNotPlusminus"));
        ++m_indent;
        DefaultVisitor::visitUnaryExpression(node);
        m_indent--;
    }

    void visitUnaryExpressionNotPlusminus(UnaryExpressionNotPlusminusAst *node) override
    {
        printToken(node, QStringLiteral("unaryExpressionNotPlusminus"));
        if (node->prefixOperatorSequence)
        {
            const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->prefixOperatorSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("postprefixOperator"), QStringLiteral("prefixOperator[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->varExpression) printToken(node->varExpression, QStringLiteral("varExpression"), QStringLiteral("varExpression"));
        if (node->postfixOperatorSequence)
        {
            const KDevPG::ListNode<PostprefixOperatorAst*> *__it = node->postfixOperatorSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("postprefixOperator"), QStringLiteral("postfixOperator[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitUnaryExpressionNotPlusminus(node);
        m_indent--;
    }

    void visitUseNamespaceOrUseGroupedNamespace(UseNamespaceOrUseGroupedNamespaceAst *node) override
    {
        printToken(node, QStringLiteral("useNamespaceOrUseGroupedNamespace"));
        if (node->identifier) printToken(node->identifier, QStringLiteral("namespacedIdentifierBeforeGroupedNamespace"), QStringLiteral("identifier"));
        if (node->aliasIdentifier) printToken(node->aliasIdentifier, QStringLiteral("identifier"), QStringLiteral("aliasIdentifier"));
        if (node->compoundNamespace) printToken(node->compoundNamespace, QStringLiteral("compoundNamespace"), QStringLiteral("compoundNamespace"));
        ++m_indent;
        DefaultVisitor::visitUseNamespaceOrUseGroupedNamespace(node);
        m_indent--;
    }

    void visitUseStatement(UseStatementAst *node) override
    {
        printToken(node, QStringLiteral("useStatement"));
        if (node->useNamespaceSequence)
        {
            const KDevPG::ListNode<UseNamespaceOrUseGroupedNamespaceAst*> *__it = node->useNamespaceSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("useNamespaceOrUseGroupedNamespace"), QStringLiteral("useNamespace[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitUseStatement(node);
        m_indent--;
    }

    void visitVarExpression(VarExpressionAst *node) override
    {
        printToken(node, QStringLiteral("varExpression"));
        if (node->printExpression) printToken(node->printExpression, QStringLiteral("assignmentExpression"), QStringLiteral("printExpression"));
        if (node->generatorExpression) printToken(node->generatorExpression, QStringLiteral("printExpression"), QStringLiteral("generatorExpression"));
        if (node->generatorValueExpr) printToken(node->generatorValueExpr, QStringLiteral("printExpression"), QStringLiteral("generatorValueExpr"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        if (node->newObject) printToken(node->newObject, QStringLiteral("varExpressionNewObject"), QStringLiteral("newObject"));
        if (node->varExpressionNormal) printToken(node->varExpressionNormal, QStringLiteral("varExpressionNormal"), QStringLiteral("varExpressionNormal"));
        if (node->varExpressionArray) printToken(node->varExpressionArray, QStringLiteral("varExpressionArray"), QStringLiteral("varExpressionArray"));
        if (node->arrayIndex) printToken(node->arrayIndex, QStringLiteral("arrayIndexSpecifier"), QStringLiteral("arrayIndex"));
        ++m_indent;
        DefaultVisitor::visitVarExpression(node);
        m_indent--;
    }

    void visitVarExpressionArray(VarExpressionArrayAst *node) override
    {
        printToken(node, QStringLiteral("varExpressionArray"));
        if (node->arrayValuesSequence)
        {
            const KDevPG::ListNode<ArrayPairValueAst*> *__it = node->arrayValuesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("arrayPairValue"), QStringLiteral("arrayValues[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitVarExpressionArray(node);
        m_indent--;
    }

    void visitVarExpressionNewObject(VarExpressionNewObjectAst *node) override
    {
        printToken(node, QStringLiteral("varExpressionNewObject"));
        if (node->classNameReference) printToken(node->classNameReference, QStringLiteral("classNameReference"), QStringLiteral("classNameReference"));
        if (node->ctor) printToken(node->ctor, QStringLiteral("ctorArguments"), QStringLiteral("ctor"));
        ++m_indent;
        DefaultVisitor::visitVarExpressionNewObject(node);
        m_indent--;
    }

    void visitVarExpressionNormal(VarExpressionNormalAst *node) override
    {
        printToken(node, QStringLiteral("varExpressionNormal"));
        if (node->iife) printToken(node->iife, QStringLiteral("iifeSyntax"), QStringLiteral("iife"));
        if (node->newObject) printToken(node->newObject, QStringLiteral("varExpressionNewObject"), QStringLiteral("newObject"));
        if (node->variablePropertiesSequence)
        {
            const KDevPG::ListNode<InstantiationAccessAst*> *__it = node->variablePropertiesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("instantiationAccess"), QStringLiteral("variableProperties[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->expression) printToken(node->expression, QStringLiteral("expr"), QStringLiteral("expression"));
        if (node->encapsList) printToken(node->encapsList, QStringLiteral("encapsList"), QStringLiteral("encapsList"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        if (node->scalar) printToken(node->scalar, QStringLiteral("scalar"), QStringLiteral("scalar"));
        if (node->issetVariableSequence)
        {
            const KDevPG::ListNode<VariableAst*> *__it = node->issetVariableSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("variable"), QStringLiteral("issetVariable[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        if (node->emptyExpression) printToken(node->emptyExpression, QStringLiteral("expr"), QStringLiteral("emptyExpression"));
        if (node->cloneCar) printToken(node->cloneCar, QStringLiteral("varExpressionNormal"), QStringLiteral("cloneCar"));
        if (node->closure) printToken(node->closure, QStringLiteral("closure"), QStringLiteral("closure"));
        ++m_indent;
        DefaultVisitor::visitVarExpressionNormal(node);
        m_indent--;
    }

    void visitVariable(VariableAst *node) override
    {
        printToken(node, QStringLiteral("variable"));
        if (node->var) printToken(node->var, QStringLiteral("baseVariableWithFunctionCalls"), QStringLiteral("var"));
        if (node->variablePropertiesSequence)
        {
            const KDevPG::ListNode<VariableObjectPropertyAst*> *__it = node->variablePropertiesSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("variableObjectProperty"), QStringLiteral("variableProperties[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitVariable(node);
        m_indent--;
    }

    void visitVariableIdentifier(VariableIdentifierAst *node) override
    {
        printToken(node, QStringLiteral("variableIdentifier"));
        ++m_indent;
        DefaultVisitor::visitVariableIdentifier(node);
        m_indent--;
    }

    void visitVariableName(VariableNameAst *node) override
    {
        printToken(node, QStringLiteral("variableName"));
        if (node->name) printToken(node->name, QStringLiteral("identifier"), QStringLiteral("name"));
        if (node->expr) printToken(node->expr, QStringLiteral("expr"), QStringLiteral("expr"));
        ++m_indent;
        DefaultVisitor::visitVariableName(node);
        m_indent--;
    }

    void visitVariableObjectProperty(VariableObjectPropertyAst *node) override
    {
        printToken(node, QStringLiteral("variableObjectProperty"));
        if (node->variableProperty) printToken(node->variableProperty, QStringLiteral("variableProperty"), QStringLiteral("variableProperty"));
        ++m_indent;
        DefaultVisitor::visitVariableObjectProperty(node);
        m_indent--;
    }

    void visitVariableProperty(VariablePropertyAst *node) override
    {
        printToken(node, QStringLiteral("variableProperty"));
        if (node->variable) printToken(node->variable, QStringLiteral("variable"), QStringLiteral("variable"));
        if (node->objectProperty) printToken(node->objectProperty, QStringLiteral("objectProperty"), QStringLiteral("objectProperty"));
        if (node->parameterList) printToken(node->parameterList, QStringLiteral("functionCallParameterList"), QStringLiteral("parameterList"));
        if (node->arrayIndex) printToken(node->arrayIndex, QStringLiteral("arrayIndexSpecifier"), QStringLiteral("arrayIndex"));
        ++m_indent;
        DefaultVisitor::visitVariableProperty(node);
        m_indent--;
    }

    void visitVariableWithoutObjects(VariableWithoutObjectsAst *node) override
    {
        printToken(node, QStringLiteral("variableWithoutObjects"));
        if (node->variable) printToken(node->variable, QStringLiteral("compoundVariableWithSimpleIndirectReference"), QStringLiteral("variable"));
        if (node->offsetItemsSequence)
        {
            const KDevPG::ListNode<DimListItemAst*> *__it = node->offsetItemsSequence->front(), *__end = __it;
            do
            {
                printToken(__it->element, QStringLiteral("dimListItem"), QStringLiteral("offsetItems[]"));
                __it = __it->next;
            }
            while (__it != __end);
        }
        ++m_indent;
        DefaultVisitor::visitVariableWithoutObjects(node);
        m_indent--;
    }

    void visitWhileStatement(WhileStatementAst *node) override
    {
        printToken(node, QStringLiteral("whileStatement"));
        if (node->statement) printToken(node->statement, QStringLiteral("statement"), QStringLiteral("statement"));
        if (node->statements) printToken(node->statements, QStringLiteral("innerStatementList"), QStringLiteral("statements"));
        ++m_indent;
        DefaultVisitor::visitWhileStatement(node);
        m_indent--;
    }

private:
    void printToken(const AstNode *node, const QString &mType, const QString &mName = QString())
    {
        KDevPG::TokenStream::Token startToken;
        KDevPG::TokenStream::Token endToken;
        qint64 line, column;
        const bool isValidStartToken = (0 <= node->startToken && node->startToken < m_str->size());
        QString startTokenString;
        if (isValidStartToken)
        {
            startToken = m_str->at(node->startToken);
            m_str->startPosition(node->startToken, &line, &column);
            startTokenString = QString::number(startToken.begin) + QLatin1String(", ") + QString::number(line) + QLatin1String(", ") + QString::number(column);
        }
        else
        {
            startTokenString = QLatin1String("invalid token index: ") + QString::number(node->startToken);
        }
        const bool isValidEndToken = (0 <= node->endToken && node->endToken < m_str->size());
        QString endTokenString;
        if (isValidEndToken)
        {
            endToken = m_str->at(node->endToken);
            m_str->startPosition(node->endToken, &line, &column);
            endTokenString = QString::number(endToken.begin) + QLatin1String(", ") + QString::number(line) + QLatin1String(", ") + QString::number(column);
        }
        else
        {
            endTokenString = QLatin1String("invalid token index: ") + QString::number(node->endToken);
        }
        QString tokenString;
        if (!m_content.isEmpty() && isValidStartToken && isValidEndToken)
        {
            const int begin = startToken.begin;
            const int end = endToken.end;
            if (end-begin > 30)
            {
                tokenString = m_content.mid(begin, 10);
                tokenString += QStringLiteral(" ...");
                tokenString += QStringLiteral("%1 more").arg(end-begin-20);
                tokenString += QStringLiteral("... ");
                tokenString += m_content.midRef(end-10, 10);
            }
            else
            {
                tokenString = m_content.mid(begin, end-begin+1);
            }
            tokenString.replace('\n', QStringLiteral("\\n"));
            tokenString.replace('\r', QStringLiteral("\\r"));
        }
        qDebug() << QString(QString().fill(QLatin1Char(' '), m_indent) + mName + QLatin1String(!mName.isEmpty() ? "->" : "") + mType + QLatin1Char('[') + startTokenString + QLatin1String("] --- [") + endTokenString + QLatin1String("] ")).toUtf8().constData() << tokenString;
    }
    TokenStream *m_str;
    int m_indent;
    QString m_content;
};

} // end of namespace Php

#endif

