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

#include "phpvisitor.h"

namespace Php
{

void Visitor::visitNode(AstNode *node)
{
    if(node)
    {
        switch(node->kind)
        {
        case AstNode::AdditiveExpressionKind:
            visitAdditiveExpression(reinterpret_cast<AdditiveExpressionAst*>(node));
            break;
        case AstNode::AdditiveExpressionRestKind:
            visitAdditiveExpressionRest(reinterpret_cast<AdditiveExpressionRestAst*>(node));
            break;
        case AstNode::ArrayIndexSpecifierKind:
            visitArrayIndexSpecifier(reinterpret_cast<ArrayIndexSpecifierAst*>(node));
            break;
        case AstNode::ArrayPairValueKind:
            visitArrayPairValue(reinterpret_cast<ArrayPairValueAst*>(node));
            break;
        case AstNode::AssignmentExpressionKind:
            visitAssignmentExpression(reinterpret_cast<AssignmentExpressionAst*>(node));
            break;
        case AstNode::AssignmentExpressionCheckIfVariableKind:
            visitAssignmentExpressionCheckIfVariable(reinterpret_cast<AssignmentExpressionCheckIfVariableAst*>(node));
            break;
        case AstNode::AssignmentExpressionEqualKind:
            visitAssignmentExpressionEqual(reinterpret_cast<AssignmentExpressionEqualAst*>(node));
            break;
        case AstNode::AssignmentListKind:
            visitAssignmentList(reinterpret_cast<AssignmentListAst*>(node));
            break;
        case AstNode::AssignmentListElementKind:
            visitAssignmentListElement(reinterpret_cast<AssignmentListElementAst*>(node));
            break;
        case AstNode::BaseVariableKind:
            visitBaseVariable(reinterpret_cast<BaseVariableAst*>(node));
            break;
        case AstNode::BaseVariableWithFunctionCallsKind:
            visitBaseVariableWithFunctionCalls(reinterpret_cast<BaseVariableWithFunctionCallsAst*>(node));
            break;
        case AstNode::BitAndExpressionKind:
            visitBitAndExpression(reinterpret_cast<BitAndExpressionAst*>(node));
            break;
        case AstNode::BitOrExpressionKind:
            visitBitOrExpression(reinterpret_cast<BitOrExpressionAst*>(node));
            break;
        case AstNode::BitXorExpressionKind:
            visitBitXorExpression(reinterpret_cast<BitXorExpressionAst*>(node));
            break;
        case AstNode::BooleanAndExpressionKind:
            visitBooleanAndExpression(reinterpret_cast<BooleanAndExpressionAst*>(node));
            break;
        case AstNode::BooleanOrExpressionKind:
            visitBooleanOrExpression(reinterpret_cast<BooleanOrExpressionAst*>(node));
            break;
        case AstNode::CaseListKind:
            visitCaseList(reinterpret_cast<CaseListAst*>(node));
            break;
        case AstNode::Case_itemKind:
            visitCase_item(reinterpret_cast<Case_itemAst*>(node));
            break;
        case AstNode::CatchItemKind:
            visitCatchItem(reinterpret_cast<CatchItemAst*>(node));
            break;
        case AstNode::ClassBodyKind:
            visitClassBody(reinterpret_cast<ClassBodyAst*>(node));
            break;
        case AstNode::ClassConstantKind:
            visitClassConstant(reinterpret_cast<ClassConstantAst*>(node));
            break;
        case AstNode::ClassConstantDeclarationKind:
            visitClassConstantDeclaration(reinterpret_cast<ClassConstantDeclarationAst*>(node));
            break;
        case AstNode::ClassDeclarationStatementKind:
            visitClassDeclarationStatement(reinterpret_cast<ClassDeclarationStatementAst*>(node));
            break;
        case AstNode::ClassExtendsKind:
            visitClassExtends(reinterpret_cast<ClassExtendsAst*>(node));
            break;
        case AstNode::ClassImplementsKind:
            visitClassImplements(reinterpret_cast<ClassImplementsAst*>(node));
            break;
        case AstNode::ClassNameKind:
            visitClassName(reinterpret_cast<ClassNameAst*>(node));
            break;
        case AstNode::ClassNameReferenceKind:
            visitClassNameReference(reinterpret_cast<ClassNameReferenceAst*>(node));
            break;
        case AstNode::ClassPropertyKind:
            visitClassProperty(reinterpret_cast<ClassPropertyAst*>(node));
            break;
        case AstNode::ClassStatementKind:
            visitClassStatement(reinterpret_cast<ClassStatementAst*>(node));
            break;
        case AstNode::ClassVariableKind:
            visitClassVariable(reinterpret_cast<ClassVariableAst*>(node));
            break;
        case AstNode::ClassVariableDeclarationKind:
            visitClassVariableDeclaration(reinterpret_cast<ClassVariableDeclarationAst*>(node));
            break;
        case AstNode::ClosureKind:
            visitClosure(reinterpret_cast<ClosureAst*>(node));
            break;
        case AstNode::CommonScalarKind:
            visitCommonScalar(reinterpret_cast<CommonScalarAst*>(node));
            break;
        case AstNode::CompoundVariableKind:
            visitCompoundVariable(reinterpret_cast<CompoundVariableAst*>(node));
            break;
        case AstNode::CompoundVariableWithSimpleIndirectReferenceKind:
            visitCompoundVariableWithSimpleIndirectReference(reinterpret_cast<CompoundVariableWithSimpleIndirectReferenceAst*>(node));
            break;
        case AstNode::ConditionalExpressionKind:
            visitConditionalExpression(reinterpret_cast<ConditionalExpressionAst*>(node));
            break;
        case AstNode::ConstantDeclarationKind:
            visitConstantDeclaration(reinterpret_cast<ConstantDeclarationAst*>(node));
            break;
        case AstNode::ConstantOrClassConstKind:
            visitConstantOrClassConst(reinterpret_cast<ConstantOrClassConstAst*>(node));
            break;
        case AstNode::CtorArgumentsKind:
            visitCtorArguments(reinterpret_cast<CtorArgumentsAst*>(node));
            break;
        case AstNode::DeclareItemKind:
            visitDeclareItem(reinterpret_cast<DeclareItemAst*>(node));
            break;
        case AstNode::DeclareStatementKind:
            visitDeclareStatement(reinterpret_cast<DeclareStatementAst*>(node));
            break;
        case AstNode::DimListItemKind:
            visitDimListItem(reinterpret_cast<DimListItemAst*>(node));
            break;
        case AstNode::ElseSingleKind:
            visitElseSingle(reinterpret_cast<ElseSingleAst*>(node));
            break;
        case AstNode::ElseifListKind:
            visitElseifList(reinterpret_cast<ElseifListAst*>(node));
            break;
        case AstNode::ElseifListItemKind:
            visitElseifListItem(reinterpret_cast<ElseifListItemAst*>(node));
            break;
        case AstNode::EncapsKind:
            visitEncaps(reinterpret_cast<EncapsAst*>(node));
            break;
        case AstNode::EncapsListKind:
            visitEncapsList(reinterpret_cast<EncapsListAst*>(node));
            break;
        case AstNode::EncapsVarKind:
            visitEncapsVar(reinterpret_cast<EncapsVarAst*>(node));
            break;
        case AstNode::EncapsVarOffsetKind:
            visitEncapsVarOffset(reinterpret_cast<EncapsVarOffsetAst*>(node));
            break;
        case AstNode::EqualityExpressionKind:
            visitEqualityExpression(reinterpret_cast<EqualityExpressionAst*>(node));
            break;
        case AstNode::EqualityExpressionRestKind:
            visitEqualityExpressionRest(reinterpret_cast<EqualityExpressionRestAst*>(node));
            break;
        case AstNode::ExprKind:
            visitExpr(reinterpret_cast<ExprAst*>(node));
            break;
        case AstNode::ForExprKind:
            visitForExpr(reinterpret_cast<ForExprAst*>(node));
            break;
        case AstNode::ForStatementKind:
            visitForStatement(reinterpret_cast<ForStatementAst*>(node));
            break;
        case AstNode::ForeachStatementKind:
            visitForeachStatement(reinterpret_cast<ForeachStatementAst*>(node));
            break;
        case AstNode::ForeachVariableKind:
            visitForeachVariable(reinterpret_cast<ForeachVariableAst*>(node));
            break;
        case AstNode::FunctionCallKind:
            visitFunctionCall(reinterpret_cast<FunctionCallAst*>(node));
            break;
        case AstNode::FunctionCallParameterListKind:
            visitFunctionCallParameterList(reinterpret_cast<FunctionCallParameterListAst*>(node));
            break;
        case AstNode::FunctionCallParameterListElementKind:
            visitFunctionCallParameterListElement(reinterpret_cast<FunctionCallParameterListElementAst*>(node));
            break;
        case AstNode::FunctionDeclarationStatementKind:
            visitFunctionDeclarationStatement(reinterpret_cast<FunctionDeclarationStatementAst*>(node));
            break;
        case AstNode::GenericTypeHintKind:
            visitGenericTypeHint(reinterpret_cast<GenericTypeHintAst*>(node));
            break;
        case AstNode::GlobalVarKind:
            visitGlobalVar(reinterpret_cast<GlobalVarAst*>(node));
            break;
        case AstNode::IdentifierKind:
            visitIdentifier(reinterpret_cast<IdentifierAst*>(node));
            break;
        case AstNode::IifeSyntaxKind:
            visitIifeSyntax(reinterpret_cast<IifeSyntaxAst*>(node));
            break;
        case AstNode::InnerStatementListKind:
            visitInnerStatementList(reinterpret_cast<InnerStatementListAst*>(node));
            break;
        case AstNode::InstantiationAccessKind:
            visitInstantiationAccess(reinterpret_cast<InstantiationAccessAst*>(node));
            break;
        case AstNode::InterfaceDeclarationStatementKind:
            visitInterfaceDeclarationStatement(reinterpret_cast<InterfaceDeclarationStatementAst*>(node));
            break;
        case AstNode::LexicalVarKind:
            visitLexicalVar(reinterpret_cast<LexicalVarAst*>(node));
            break;
        case AstNode::LexicalVarListKind:
            visitLexicalVarList(reinterpret_cast<LexicalVarListAst*>(node));
            break;
        case AstNode::LogicalAndExpressionKind:
            visitLogicalAndExpression(reinterpret_cast<LogicalAndExpressionAst*>(node));
            break;
        case AstNode::LogicalOrExpressionKind:
            visitLogicalOrExpression(reinterpret_cast<LogicalOrExpressionAst*>(node));
            break;
        case AstNode::LogicalXorExpressionKind:
            visitLogicalXorExpression(reinterpret_cast<LogicalXorExpressionAst*>(node));
            break;
        case AstNode::MethodBodyKind:
            visitMethodBody(reinterpret_cast<MethodBodyAst*>(node));
            break;
        case AstNode::MultiplicativeExpressionKind:
            visitMultiplicativeExpression(reinterpret_cast<MultiplicativeExpressionAst*>(node));
            break;
        case AstNode::MultiplicativeExpressionRestKind:
            visitMultiplicativeExpressionRest(reinterpret_cast<MultiplicativeExpressionRestAst*>(node));
            break;
        case AstNode::NamespaceDeclarationStatementKind:
            visitNamespaceDeclarationStatement(reinterpret_cast<NamespaceDeclarationStatementAst*>(node));
            break;
        case AstNode::NamespacedIdentifierKind:
            visitNamespacedIdentifier(reinterpret_cast<NamespacedIdentifierAst*>(node));
            break;
        case AstNode::NewElseSingleKind:
            visitNewElseSingle(reinterpret_cast<NewElseSingleAst*>(node));
            break;
        case AstNode::NewElseifListKind:
            visitNewElseifList(reinterpret_cast<NewElseifListAst*>(node));
            break;
        case AstNode::NewelseifListItemKind:
            visitNewelseifListItem(reinterpret_cast<NewelseifListItemAst*>(node));
            break;
        case AstNode::NullCoalesceExpressionKind:
            visitNullCoalesceExpression(reinterpret_cast<NullCoalesceExpressionAst*>(node));
            break;
        case AstNode::ObjectDimListKind:
            visitObjectDimList(reinterpret_cast<ObjectDimListAst*>(node));
            break;
        case AstNode::ObjectOperatorKind:
            visitObjectOperator(reinterpret_cast<ObjectOperatorAst*>(node));
            break;
        case AstNode::ObjectPropertyKind:
            visitObjectProperty(reinterpret_cast<ObjectPropertyAst*>(node));
            break;
        case AstNode::OptionalClassModifierKind:
            visitOptionalClassModifier(reinterpret_cast<OptionalClassModifierAst*>(node));
            break;
        case AstNode::OptionalModifiersKind:
            visitOptionalModifiers(reinterpret_cast<OptionalModifiersAst*>(node));
            break;
        case AstNode::OuterTopStatementKind:
            visitOuterTopStatement(reinterpret_cast<OuterTopStatementAst*>(node));
            break;
        case AstNode::ParameterKind:
            visitParameter(reinterpret_cast<ParameterAst*>(node));
            break;
        case AstNode::ParameterListKind:
            visitParameterList(reinterpret_cast<ParameterListAst*>(node));
            break;
        case AstNode::ParameterTypeKind:
            visitParameterType(reinterpret_cast<ParameterTypeAst*>(node));
            break;
        case AstNode::PostprefixOperatorKind:
            visitPostprefixOperator(reinterpret_cast<PostprefixOperatorAst*>(node));
            break;
        case AstNode::PrintExpressionKind:
            visitPrintExpression(reinterpret_cast<PrintExpressionAst*>(node));
            break;
        case AstNode::PropertyTypeKind:
            visitPropertyType(reinterpret_cast<PropertyTypeAst*>(node));
            break;
        case AstNode::PropertyTypeHintKind:
            visitPropertyTypeHint(reinterpret_cast<PropertyTypeHintAst*>(node));
            break;
        case AstNode::RelationalExpressionKind:
            visitRelationalExpression(reinterpret_cast<RelationalExpressionAst*>(node));
            break;
        case AstNode::RelationalExpressionRestKind:
            visitRelationalExpressionRest(reinterpret_cast<RelationalExpressionRestAst*>(node));
            break;
        case AstNode::ReservedNonModifierIdentifierKind:
            visitReservedNonModifierIdentifier(reinterpret_cast<ReservedNonModifierIdentifierAst*>(node));
            break;
        case AstNode::ReservedNonModifiersKind:
            visitReservedNonModifiers(reinterpret_cast<ReservedNonModifiersAst*>(node));
            break;
        case AstNode::ReturnTypeKind:
            visitReturnType(reinterpret_cast<ReturnTypeAst*>(node));
            break;
        case AstNode::ScalarKind:
            visitScalar(reinterpret_cast<ScalarAst*>(node));
            break;
        case AstNode::SemiReservedKind:
            visitSemiReserved(reinterpret_cast<SemiReservedAst*>(node));
            break;
        case AstNode::SemiReservedIdentifierKind:
            visitSemiReservedIdentifier(reinterpret_cast<SemiReservedIdentifierAst*>(node));
            break;
        case AstNode::SemicolonOrCloseTagKind:
            visitSemicolonOrCloseTag(reinterpret_cast<SemicolonOrCloseTagAst*>(node));
            break;
        case AstNode::ShiftExpressionKind:
            visitShiftExpression(reinterpret_cast<ShiftExpressionAst*>(node));
            break;
        case AstNode::ShiftExpressionRestKind:
            visitShiftExpressionRest(reinterpret_cast<ShiftExpressionRestAst*>(node));
            break;
        case AstNode::StartKind:
            visitStart(reinterpret_cast<StartAst*>(node));
            break;
        case AstNode::StatementKind:
            visitStatement(reinterpret_cast<StatementAst*>(node));
            break;
        case AstNode::StaticArrayPairValueKind:
            visitStaticArrayPairValue(reinterpret_cast<StaticArrayPairValueAst*>(node));
            break;
        case AstNode::StaticMemberKind:
            visitStaticMember(reinterpret_cast<StaticMemberAst*>(node));
            break;
        case AstNode::StaticPropertyKind:
            visitStaticProperty(reinterpret_cast<StaticPropertyAst*>(node));
            break;
        case AstNode::StaticScalarKind:
            visitStaticScalar(reinterpret_cast<StaticScalarAst*>(node));
            break;
        case AstNode::StaticVarKind:
            visitStaticVar(reinterpret_cast<StaticVarAst*>(node));
            break;
        case AstNode::StringIndexSpecifierKind:
            visitStringIndexSpecifier(reinterpret_cast<StringIndexSpecifierAst*>(node));
            break;
        case AstNode::SwitchCaseListKind:
            visitSwitchCaseList(reinterpret_cast<SwitchCaseListAst*>(node));
            break;
        case AstNode::TopStatementKind:
            visitTopStatement(reinterpret_cast<TopStatementAst*>(node));
            break;
        case AstNode::TraitAliasDeclarationKind:
            visitTraitAliasDeclaration(reinterpret_cast<TraitAliasDeclarationAst*>(node));
            break;
        case AstNode::TraitAliasIdentifierKind:
            visitTraitAliasIdentifier(reinterpret_cast<TraitAliasIdentifierAst*>(node));
            break;
        case AstNode::TraitAliasStatementKind:
            visitTraitAliasStatement(reinterpret_cast<TraitAliasStatementAst*>(node));
            break;
        case AstNode::TraitDeclarationStatementKind:
            visitTraitDeclarationStatement(reinterpret_cast<TraitDeclarationStatementAst*>(node));
            break;
        case AstNode::TraitVisibilityModifiersKind:
            visitTraitVisibilityModifiers(reinterpret_cast<TraitVisibilityModifiersAst*>(node));
            break;
        case AstNode::UnaryExpressionKind:
            visitUnaryExpression(reinterpret_cast<UnaryExpressionAst*>(node));
            break;
        case AstNode::UnaryExpressionNotPlusminusKind:
            visitUnaryExpressionNotPlusminus(reinterpret_cast<UnaryExpressionNotPlusminusAst*>(node));
            break;
        case AstNode::UseNamespaceKind:
            visitUseNamespace(reinterpret_cast<UseNamespaceAst*>(node));
            break;
        case AstNode::UseStatementKind:
            visitUseStatement(reinterpret_cast<UseStatementAst*>(node));
            break;
        case AstNode::VarExpressionKind:
            visitVarExpression(reinterpret_cast<VarExpressionAst*>(node));
            break;
        case AstNode::VarExpressionArrayKind:
            visitVarExpressionArray(reinterpret_cast<VarExpressionArrayAst*>(node));
            break;
        case AstNode::VarExpressionNewObjectKind:
            visitVarExpressionNewObject(reinterpret_cast<VarExpressionNewObjectAst*>(node));
            break;
        case AstNode::VarExpressionNormalKind:
            visitVarExpressionNormal(reinterpret_cast<VarExpressionNormalAst*>(node));
            break;
        case AstNode::VariableKind:
            visitVariable(reinterpret_cast<VariableAst*>(node));
            break;
        case AstNode::VariableIdentifierKind:
            visitVariableIdentifier(reinterpret_cast<VariableIdentifierAst*>(node));
            break;
        case AstNode::VariableNameKind:
            visitVariableName(reinterpret_cast<VariableNameAst*>(node));
            break;
        case AstNode::VariableObjectPropertyKind:
            visitVariableObjectProperty(reinterpret_cast<VariableObjectPropertyAst*>(node));
            break;
        case AstNode::VariablePropertyKind:
            visitVariableProperty(reinterpret_cast<VariablePropertyAst*>(node));
            break;
        case AstNode::VariableWithoutObjectsKind:
            visitVariableWithoutObjects(reinterpret_cast<VariableWithoutObjectsAst*>(node));
            break;
        case AstNode::WhileStatementKind:
            visitWhileStatement(reinterpret_cast<WhileStatementAst*>(node));
            break;
        default:
            Q_ASSERT(false);
        }
    }
}

} // end of namespace Php

