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

#ifndef PHP_AST_H_INCLUDED
#define PHP_AST_H_INCLUDED

#include "phpast-fwd.h"

#include "parserexport.h"
#include <QList>
#include <kdev-pg-list.h>


# 45 "/build/kdevelop-php/src/kdev-php-22.08.3/parser/php.g" 1


#include <QtCore/QRegularExpression>

namespace KDevelop
{
class DUContext;
}


namespace Php
{


# 79 "/build/kdevelop-php/src/kdev-php-22.08.3/parser/php.g" 1

class Lexer;

enum ModifierFlags
{
    ModifierPrivate      = 1,
    ModifierPublic       = 1 << 1,
    ModifierProtected    = 1 << 2,
    ModifierStatic       = 1 << 3,
    ModifierFinal        = 1 << 4,
    ModifierAbstract     = 1 << 5
};

enum ClassModifier
{
    NormalClass,
    AbstractClass,
    FinalClass
};

enum ScalarTypes
{
    ScalarTypeInt,
    ScalarTypeFloat,
    ScalarTypeString
};

enum CastType
{
    CastInt,
    CastDouble,
    CastString,
    CastArray,
    CastObject,
    CastBool,
    CastUnset
};

enum OperationType
{
    OperationPlus = 1,
    OperationMinus,
    OperationConcat,
    OperationMul,
    OperationDiv,
    OperationExp,
    OperationMod,
    OperationAnd,
    OperationOr,
    OperationXor,
    OperationSl,
    OperationSr,
    OperationSpaceship,
};

struct KDEVPHPPARSER_EXPORT AstNode
{
    enum AstNodeKind
    {
        AdditiveExpressionKind = 1000,
        AdditiveExpressionRestKind = 1001,
        ArrayIndexSpecifierKind = 1002,
        ArrayPairValueKind = 1003,
        AssignmentExpressionKind = 1004,
        AssignmentExpressionCheckIfVariableKind = 1005,
        AssignmentExpressionEqualKind = 1006,
        AssignmentListKind = 1007,
        AssignmentListElementKind = 1008,
        BaseVariableKind = 1009,
        BaseVariableWithFunctionCallsKind = 1010,
        BitAndExpressionKind = 1011,
        BitOrExpressionKind = 1012,
        BitXorExpressionKind = 1013,
        BooleanAndExpressionKind = 1014,
        BooleanOrExpressionKind = 1015,
        CaseListKind = 1016,
        Case_itemKind = 1017,
        CatchItemKind = 1018,
        ClassBodyKind = 1019,
        ClassConstantKind = 1020,
        ClassConstantDeclarationKind = 1021,
        ClassDeclarationStatementKind = 1022,
        ClassExtendsKind = 1023,
        ClassImplementsKind = 1024,
        ClassNameKind = 1025,
        ClassNameReferenceKind = 1026,
        ClassPropertyKind = 1027,
        ClassStatementKind = 1028,
        ClassVariableKind = 1029,
        ClassVariableDeclarationKind = 1030,
        ClosureKind = 1031,
        CommonScalarKind = 1032,
        CompoundVariableKind = 1033,
        CompoundVariableWithSimpleIndirectReferenceKind = 1034,
        ConditionalExpressionKind = 1035,
        ConstantDeclarationKind = 1036,
        ConstantOrClassConstKind = 1037,
        CtorArgumentsKind = 1038,
        DeclareItemKind = 1039,
        DeclareStatementKind = 1040,
        DimListItemKind = 1041,
        ElseSingleKind = 1042,
        ElseifListKind = 1043,
        ElseifListItemKind = 1044,
        EncapsKind = 1045,
        EncapsListKind = 1046,
        EncapsVarKind = 1047,
        EncapsVarOffsetKind = 1048,
        EqualityExpressionKind = 1049,
        EqualityExpressionRestKind = 1050,
        ExprKind = 1051,
        ForExprKind = 1052,
        ForStatementKind = 1053,
        ForeachStatementKind = 1054,
        ForeachVariableKind = 1055,
        FunctionCallKind = 1056,
        FunctionCallParameterListKind = 1057,
        FunctionCallParameterListElementKind = 1058,
        FunctionDeclarationStatementKind = 1059,
        GenericTypeHintKind = 1060,
        GlobalVarKind = 1061,
        IdentifierKind = 1062,
        IifeSyntaxKind = 1063,
        InnerStatementListKind = 1064,
        InstantiationAccessKind = 1065,
        InterfaceDeclarationStatementKind = 1066,
        LexicalVarKind = 1067,
        LexicalVarListKind = 1068,
        LogicalAndExpressionKind = 1069,
        LogicalOrExpressionKind = 1070,
        LogicalXorExpressionKind = 1071,
        MethodBodyKind = 1072,
        MultiplicativeExpressionKind = 1073,
        MultiplicativeExpressionRestKind = 1074,
        NamespaceDeclarationStatementKind = 1075,
        NamespacedIdentifierKind = 1076,
        NewElseSingleKind = 1077,
        NewElseifListKind = 1078,
        NewelseifListItemKind = 1079,
        NullCoalesceExpressionKind = 1080,
        ObjectDimListKind = 1081,
        ObjectOperatorKind = 1082,
        ObjectPropertyKind = 1083,
        OptionalClassModifierKind = 1084,
        OptionalModifiersKind = 1085,
        OuterTopStatementKind = 1086,
        ParameterKind = 1087,
        ParameterListKind = 1088,
        ParameterTypeKind = 1089,
        PostprefixOperatorKind = 1090,
        PrintExpressionKind = 1091,
        PropertyTypeKind = 1092,
        PropertyTypeHintKind = 1093,
        RelationalExpressionKind = 1094,
        RelationalExpressionRestKind = 1095,
        ReservedNonModifierIdentifierKind = 1096,
        ReservedNonModifiersKind = 1097,
        ReturnTypeKind = 1098,
        ScalarKind = 1099,
        SemiReservedKind = 1100,
        SemiReservedIdentifierKind = 1101,
        SemicolonOrCloseTagKind = 1102,
        ShiftExpressionKind = 1103,
        ShiftExpressionRestKind = 1104,
        StartKind = 1105,
        StatementKind = 1106,
        StaticArrayPairValueKind = 1107,
        StaticMemberKind = 1108,
        StaticPropertyKind = 1109,
        StaticScalarKind = 1110,
        StaticVarKind = 1111,
        StringIndexSpecifierKind = 1112,
        SwitchCaseListKind = 1113,
        TopStatementKind = 1114,
        TraitAliasDeclarationKind = 1115,
        TraitAliasIdentifierKind = 1116,
        TraitAliasStatementKind = 1117,
        TraitDeclarationStatementKind = 1118,
        TraitVisibilityModifiersKind = 1119,
        UnaryExpressionKind = 1120,
        UnaryExpressionNotPlusminusKind = 1121,
        UseNamespaceKind = 1122,
        UseStatementKind = 1123,
        VarExpressionKind = 1124,
        VarExpressionArrayKind = 1125,
        VarExpressionNewObjectKind = 1126,
        VarExpressionNormalKind = 1127,
        VariableKind = 1128,
        VariableIdentifierKind = 1129,
        VariableNameKind = 1130,
        VariableObjectPropertyKind = 1131,
        VariablePropertyKind = 1132,
        VariableWithoutObjectsKind = 1133,
        WhileStatementKind = 1134,
        AST_NODE_KIND_COUNT
    };

    int kind;
    qint64 startToken;
    qint64 endToken;

# 134 "/build/kdevelop-php/src/kdev-php-22.08.3/parser/php.g" 1

    KDevelop::DUContext* ducontext;

};

struct KDEVPHPPARSER_EXPORT AdditiveExpressionAst: public AstNode
{
    enum { KIND = AdditiveExpressionKind };

    MultiplicativeExpressionAst *expression;
    const KDevPG::ListNode<AdditiveExpressionRestAst *> *additionalExpressionSequence;
};

struct KDEVPHPPARSER_EXPORT AdditiveExpressionRestAst: public AstNode
{
    enum { KIND = AdditiveExpressionRestKind };

    OperationType operation;
    MultiplicativeExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT ArrayIndexSpecifierAst: public AstNode
{
    enum { KIND = ArrayIndexSpecifierKind };

    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT ArrayPairValueAst: public AstNode
{
    enum { KIND = ArrayPairValueKind };

    ExprAst *expr;
    ExprAst *exprValue;
    VariableAst *varValue;
    VariableAst *variable;
};

struct KDEVPHPPARSER_EXPORT AssignmentExpressionAst: public AstNode
{
    enum { KIND = AssignmentExpressionKind };

    OperationType operation;
    ConditionalExpressionAst *expression;
    AssignmentExpressionEqualAst *assignmentExpressionEqual;
    AssignmentExpressionAst *assignmentExpression;
};

struct KDEVPHPPARSER_EXPORT AssignmentExpressionCheckIfVariableAst: public AstNode
{
    enum { KIND = AssignmentExpressionCheckIfVariableKind };

};

struct KDEVPHPPARSER_EXPORT AssignmentExpressionEqualAst: public AstNode
{
    enum { KIND = AssignmentExpressionEqualKind };

    AssignmentExpressionAst *assignmentExpression;
};

struct KDEVPHPPARSER_EXPORT AssignmentListAst: public AstNode
{
    enum { KIND = AssignmentListKind };

    const KDevPG::ListNode<AssignmentListElementAst *> *elementSequence;
};

struct KDEVPHPPARSER_EXPORT AssignmentListElementAst: public AstNode
{
    enum { KIND = AssignmentListElementKind };

    VariableAst *variable;
    AssignmentListAst *assignmentList;
};

struct KDEVPHPPARSER_EXPORT BaseVariableAst: public AstNode
{
    enum { KIND = BaseVariableKind };

    CompoundVariableWithSimpleIndirectReferenceAst *var;
    const KDevPG::ListNode<DimListItemAst *> *offsetItemsSequence;
    StaticMemberAst *staticMember;
};

struct KDEVPHPPARSER_EXPORT BaseVariableWithFunctionCallsAst: public AstNode
{
    enum { KIND = BaseVariableWithFunctionCallsKind };

    FunctionCallAst *functionCall;
    ArrayIndexSpecifierAst *arrayIndex;
    BaseVariableAst *baseVariable;
};

struct KDEVPHPPARSER_EXPORT BitAndExpressionAst: public AstNode
{
    enum { KIND = BitAndExpressionKind };

    const KDevPG::ListNode<EqualityExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT BitOrExpressionAst: public AstNode
{
    enum { KIND = BitOrExpressionKind };

    const KDevPG::ListNode<BitXorExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT BitXorExpressionAst: public AstNode
{
    enum { KIND = BitXorExpressionKind };

    const KDevPG::ListNode<BitAndExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT BooleanAndExpressionAst: public AstNode
{
    enum { KIND = BooleanAndExpressionKind };

    const KDevPG::ListNode<BitOrExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT BooleanOrExpressionAst: public AstNode
{
    enum { KIND = BooleanOrExpressionKind };

    const KDevPG::ListNode<BooleanAndExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT CaseListAst: public AstNode
{
    enum { KIND = CaseListKind };

    const KDevPG::ListNode<Case_itemAst *> *caseItemsSequence;
};

struct KDEVPHPPARSER_EXPORT Case_itemAst: public AstNode
{
    enum { KIND = Case_itemKind };

    ExprAst *expr;
    InnerStatementListAst *statements;
    qint64 def;
};

struct KDEVPHPPARSER_EXPORT CatchItemAst: public AstNode
{
    enum { KIND = CatchItemKind };

    const KDevPG::ListNode<NamespacedIdentifierAst *> *catchClassSequence;
    VariableIdentifierAst *var;
    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT ClassBodyAst: public AstNode
{
    enum { KIND = ClassBodyKind };

    const KDevPG::ListNode<ClassStatementAst *> *classStatementsSequence;
};

struct KDEVPHPPARSER_EXPORT ClassConstantAst: public AstNode
{
    enum { KIND = ClassConstantKind };

};

struct KDEVPHPPARSER_EXPORT ClassConstantDeclarationAst: public AstNode
{
    enum { KIND = ClassConstantDeclarationKind };

    SemiReservedIdentifierAst *identifier;
    ExprAst *scalar;
};

struct KDEVPHPPARSER_EXPORT ClassDeclarationStatementAst: public AstNode
{
    enum { KIND = ClassDeclarationStatementKind };

    OptionalClassModifierAst *modifier;
    IdentifierAst *className;
    ClassExtendsAst *extends;
    ClassImplementsAst *implements;
    ClassBodyAst *body;
};

struct KDEVPHPPARSER_EXPORT ClassExtendsAst: public AstNode
{
    enum { KIND = ClassExtendsKind };

    NamespacedIdentifierAst *identifier;
};

struct KDEVPHPPARSER_EXPORT ClassImplementsAst: public AstNode
{
    enum { KIND = ClassImplementsKind };

    const KDevPG::ListNode<NamespacedIdentifierAst *> *implementsSequence;
};

struct KDEVPHPPARSER_EXPORT ClassNameAst: public AstNode
{
    enum { KIND = ClassNameKind };

    NamespacedIdentifierAst *identifier;
    qint64 staticIdentifier;
};

struct KDEVPHPPARSER_EXPORT ClassNameReferenceAst: public AstNode
{
    enum { KIND = ClassNameReferenceKind };

    ClassNameAst *className;
    StaticPropertyAst *staticProperty;
    const KDevPG::ListNode<ClassPropertyAst *> *propertiesSequence;
    VariableWithoutObjectsAst *baseVariable;
};

struct KDEVPHPPARSER_EXPORT ClassPropertyAst: public AstNode
{
    enum { KIND = ClassPropertyKind };

    StaticPropertyAst *staticProperty;
    ObjectPropertyAst *property;
};

struct KDEVPHPPARSER_EXPORT ClassStatementAst: public AstNode
{
    enum { KIND = ClassStatementKind };

    ClassVariableDeclarationAst *variable;
    OptionalModifiersAst *modifiers;
    PropertyTypeAst *propertyType;
    SemiReservedIdentifierAst *methodName;
    ParameterListAst *parameters;
    ReturnTypeAst *returnType;
    MethodBodyAst *methodBody;
    const KDevPG::ListNode<ClassConstantDeclarationAst *> *constsSequence;
    const KDevPG::ListNode<NamespacedIdentifierAst *> *traitsSequence;
    TraitAliasDeclarationAst *imports;
};

struct KDEVPHPPARSER_EXPORT ClassVariableAst: public AstNode
{
    enum { KIND = ClassVariableKind };

    VariableIdentifierAst *variable;
    StaticScalarAst *value;
};

struct KDEVPHPPARSER_EXPORT ClassVariableDeclarationAst: public AstNode
{
    enum { KIND = ClassVariableDeclarationKind };

    const KDevPG::ListNode<ClassVariableAst *> *varsSequence;
};

struct KDEVPHPPARSER_EXPORT ClosureAst: public AstNode
{
    enum { KIND = ClosureKind };

    qint64 isRef;
    ParameterListAst *parameters;
    LexicalVarListAst *lexicalVars;
    ReturnTypeAst *returnType;
    InnerStatementListAst *functionBody;
};

struct KDEVPHPPARSER_EXPORT CommonScalarAst: public AstNode
{
    enum { KIND = CommonScalarKind };

    ScalarTypes scalarType;
    qint64 string;
    StringIndexSpecifierAst *stringIndex;
};

struct KDEVPHPPARSER_EXPORT CompoundVariableAst: public AstNode
{
    enum { KIND = CompoundVariableKind };

    VariableIdentifierAst *variable;
    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT CompoundVariableWithSimpleIndirectReferenceAst: public AstNode
{
    enum { KIND = CompoundVariableWithSimpleIndirectReferenceKind };

    VariableIdentifierAst *indirectVariable;
    ExprAst *expr;
    VariableIdentifierAst *variable;
};

struct KDEVPHPPARSER_EXPORT ConditionalExpressionAst: public AstNode
{
    enum { KIND = ConditionalExpressionKind };

    NullCoalesceExpressionAst *expression;
    ExprAst *ifExpression;
    ConditionalExpressionAst *elseExpression;
};

struct KDEVPHPPARSER_EXPORT ConstantDeclarationAst: public AstNode
{
    enum { KIND = ConstantDeclarationKind };

    IdentifierAst *identifier;
    ExprAst *scalar;
};

struct KDEVPHPPARSER_EXPORT ConstantOrClassConstAst: public AstNode
{
    enum { KIND = ConstantOrClassConstKind };

    NamespacedIdentifierAst *constant;
    ClassConstantAst *classConstant;
};

struct KDEVPHPPARSER_EXPORT CtorArgumentsAst: public AstNode
{
    enum { KIND = CtorArgumentsKind };

    FunctionCallParameterListAst *parameterList;
};

struct KDEVPHPPARSER_EXPORT DeclareItemAst: public AstNode
{
    enum { KIND = DeclareItemKind };

    StaticScalarAst *scalar;
};

struct KDEVPHPPARSER_EXPORT DeclareStatementAst: public AstNode
{
    enum { KIND = DeclareStatementKind };

    StatementAst *statement;
    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT DimListItemAst: public AstNode
{
    enum { KIND = DimListItemKind };

    ArrayIndexSpecifierAst *arrayIndex;
    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT ElseSingleAst: public AstNode
{
    enum { KIND = ElseSingleKind };

    StatementAst *statement;
};

struct KDEVPHPPARSER_EXPORT ElseifListAst: public AstNode
{
    enum { KIND = ElseifListKind };

    const KDevPG::ListNode<ElseifListItemAst *> *elseifListItemSequence;
};

struct KDEVPHPPARSER_EXPORT ElseifListItemAst: public AstNode
{
    enum { KIND = ElseifListItemKind };

    ExprAst *expr;
    StatementAst *statement;
};

struct KDEVPHPPARSER_EXPORT EncapsAst: public AstNode
{
    enum { KIND = EncapsKind };

    EncapsVarAst *var;
    qint64 value;
};

struct KDEVPHPPARSER_EXPORT EncapsListAst: public AstNode
{
    enum { KIND = EncapsListKind };

    const KDevPG::ListNode<EncapsAst *> *encapsSequence;
};

struct KDEVPHPPARSER_EXPORT EncapsVarAst: public AstNode
{
    enum { KIND = EncapsVarKind };

    ArrayIndexSpecifierAst *arrayIndex;
    ExprAst *expr;
    VariableIdentifierAst *variable;
    IdentifierAst *propertyIdentifier;
    EncapsVarOffsetAst *offset;
};

struct KDEVPHPPARSER_EXPORT EncapsVarOffsetAst: public AstNode
{
    enum { KIND = EncapsVarOffsetKind };

};

struct KDEVPHPPARSER_EXPORT EqualityExpressionAst: public AstNode
{
    enum { KIND = EqualityExpressionKind };

    RelationalExpressionAst *expression;
    EqualityExpressionRestAst *additionalExpression;
};

struct KDEVPHPPARSER_EXPORT EqualityExpressionRestAst: public AstNode
{
    enum { KIND = EqualityExpressionRestKind };

    OperationType operation;
    RelationalExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT ExprAst: public AstNode
{
    enum { KIND = ExprKind };

    LogicalOrExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT ForExprAst: public AstNode
{
    enum { KIND = ForExprKind };

    const KDevPG::ListNode<ExprAst *> *exprsSequence;
};

struct KDEVPHPPARSER_EXPORT ForStatementAst: public AstNode
{
    enum { KIND = ForStatementKind };

    StatementAst *statement;
    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT ForeachStatementAst: public AstNode
{
    enum { KIND = ForeachStatementKind };

    StatementAst *statement;
    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT ForeachVariableAst: public AstNode
{
    enum { KIND = ForeachVariableKind };

    VariableAst *variable;
};

struct KDEVPHPPARSER_EXPORT FunctionCallAst: public AstNode
{
    enum { KIND = FunctionCallKind };

    NamespacedIdentifierAst *stringFunctionNameOrClass;
    FunctionCallParameterListAst *stringParameterList;
    SemiReservedIdentifierAst *stringFunctionName;
    VariableWithoutObjectsAst *varFunctionName;
    ExprAst *expr;
    FunctionCallParameterListAst *varParameterList;
};

struct KDEVPHPPARSER_EXPORT FunctionCallParameterListAst: public AstNode
{
    enum { KIND = FunctionCallParameterListKind };

    const KDevPG::ListNode<FunctionCallParameterListElementAst *> *parametersSequence;
};

struct KDEVPHPPARSER_EXPORT FunctionCallParameterListElementAst: public AstNode
{
    enum { KIND = FunctionCallParameterListElementKind };

    VariableAst *variable;
    qint64 isVariadic;
    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT FunctionDeclarationStatementAst: public AstNode
{
    enum { KIND = FunctionDeclarationStatementKind };

    IdentifierAst *functionName;
    ParameterListAst *parameters;
    ReturnTypeAst *returnType;
    InnerStatementListAst *functionBody;
};

struct KDEVPHPPARSER_EXPORT GenericTypeHintAst: public AstNode
{
    enum { KIND = GenericTypeHintKind };

    NamespacedIdentifierAst *genericType;
    qint64 arrayType;
    qint64 callableType;
};

struct KDEVPHPPARSER_EXPORT GlobalVarAst: public AstNode
{
    enum { KIND = GlobalVarKind };

    VariableIdentifierAst *var;
    VariableAst *dollarVar;
    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT IdentifierAst: public AstNode
{
    enum { KIND = IdentifierKind };

    qint64 string;
};

struct KDEVPHPPARSER_EXPORT IifeSyntaxAst: public AstNode
{
    enum { KIND = IifeSyntaxKind };

    ClosureAst *closure;
    FunctionCallParameterListAst *parameterList;
    ExprAst *expression;
};

struct KDEVPHPPARSER_EXPORT InnerStatementListAst: public AstNode
{
    enum { KIND = InnerStatementListKind };

    const KDevPG::ListNode<TopStatementAst *> *statementsSequence;
};

struct KDEVPHPPARSER_EXPORT InstantiationAccessAst: public AstNode
{
    enum { KIND = InstantiationAccessKind };

    VariablePropertyAst *variableProperty;
};

struct KDEVPHPPARSER_EXPORT InterfaceDeclarationStatementAst: public AstNode
{
    enum { KIND = InterfaceDeclarationStatementKind };

    IdentifierAst *interfaceName;
    ClassImplementsAst *extends;
    ClassBodyAst *body;
};

struct KDEVPHPPARSER_EXPORT LexicalVarAst: public AstNode
{
    enum { KIND = LexicalVarKind };

    qint64 isRef;
    VariableIdentifierAst *variable;
};

struct KDEVPHPPARSER_EXPORT LexicalVarListAst: public AstNode
{
    enum { KIND = LexicalVarListKind };

    const KDevPG::ListNode<LexicalVarAst *> *lexicalVarsSequence;
};

struct KDEVPHPPARSER_EXPORT LogicalAndExpressionAst: public AstNode
{
    enum { KIND = LogicalAndExpressionKind };

    const KDevPG::ListNode<PrintExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT LogicalOrExpressionAst: public AstNode
{
    enum { KIND = LogicalOrExpressionKind };

    const KDevPG::ListNode<LogicalXorExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT LogicalXorExpressionAst: public AstNode
{
    enum { KIND = LogicalXorExpressionKind };

    const KDevPG::ListNode<LogicalAndExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT MethodBodyAst: public AstNode
{
    enum { KIND = MethodBodyKind };

    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT MultiplicativeExpressionAst: public AstNode
{
    enum { KIND = MultiplicativeExpressionKind };

    UnaryExpressionAst *expression;
    const KDevPG::ListNode<MultiplicativeExpressionRestAst *> *additionalExpressionSequence;
};

struct KDEVPHPPARSER_EXPORT MultiplicativeExpressionRestAst: public AstNode
{
    enum { KIND = MultiplicativeExpressionRestKind };

    OperationType operation;
    UnaryExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT NamespaceDeclarationStatementAst: public AstNode
{
    enum { KIND = NamespaceDeclarationStatementKind };

    const KDevPG::ListNode<IdentifierAst *> *namespaceNameSequence;
    InnerStatementListAst *body;
};

struct KDEVPHPPARSER_EXPORT NamespacedIdentifierAst: public AstNode
{
    enum { KIND = NamespacedIdentifierKind };

    qint64 isGlobal;
    const KDevPG::ListNode<IdentifierAst *> *namespaceNameSequence;
};

struct KDEVPHPPARSER_EXPORT NewElseSingleAst: public AstNode
{
    enum { KIND = NewElseSingleKind };

    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT NewElseifListAst: public AstNode
{
    enum { KIND = NewElseifListKind };

    const KDevPG::ListNode<NewelseifListItemAst *> *newElseifListItemSequence;
};

struct KDEVPHPPARSER_EXPORT NewelseifListItemAst: public AstNode
{
    enum { KIND = NewelseifListItemKind };

    ExprAst *expr;
    InnerStatementListAst *statements;
};

struct KDEVPHPPARSER_EXPORT NullCoalesceExpressionAst: public AstNode
{
    enum { KIND = NullCoalesceExpressionKind };

    const KDevPG::ListNode<BooleanOrExpressionAst *> *expressionSequence;
};

struct KDEVPHPPARSER_EXPORT ObjectDimListAst: public AstNode
{
    enum { KIND = ObjectDimListKind };

    VariableNameAst *variableName;
    const KDevPG::ListNode<DimListItemAst *> *offsetItemsSequence;
};

struct KDEVPHPPARSER_EXPORT ObjectOperatorAst: public AstNode
{
    enum { KIND = ObjectOperatorKind };

};

struct KDEVPHPPARSER_EXPORT ObjectPropertyAst: public AstNode
{
    enum { KIND = ObjectPropertyKind };

    ObjectDimListAst *objectDimList;
    VariableWithoutObjectsAst *variableWithoutObjects;
};

struct KDEVPHPPARSER_EXPORT OptionalClassModifierAst: public AstNode
{
    enum { KIND = OptionalClassModifierKind };

    ClassModifier modifier;
};

struct KDEVPHPPARSER_EXPORT OptionalModifiersAst: public AstNode
{
    enum { KIND = OptionalModifiersKind };

    unsigned int modifiers;
};

struct KDEVPHPPARSER_EXPORT OuterTopStatementAst: public AstNode
{
    enum { KIND = OuterTopStatementKind };

    NamespaceDeclarationStatementAst *namespaceDeclaration;
    TopStatementAst *statement;
};

struct KDEVPHPPARSER_EXPORT ParameterAst: public AstNode
{
    enum { KIND = ParameterKind };

    ParameterTypeAst *parameterType;
    qint64 isRef;
    qint64 isVariadic;
    VariableIdentifierAst *variable;
    ExprAst *defaultValue;
};

struct KDEVPHPPARSER_EXPORT ParameterListAst: public AstNode
{
    enum { KIND = ParameterListKind };

    const KDevPG::ListNode<ParameterAst *> *parametersSequence;
};

struct KDEVPHPPARSER_EXPORT ParameterTypeAst: public AstNode
{
    enum { KIND = ParameterTypeKind };

    qint64 isNullable;
    GenericTypeHintAst *typehint;
};

struct KDEVPHPPARSER_EXPORT PostprefixOperatorAst: public AstNode
{
    enum { KIND = PostprefixOperatorKind };

    qint64 op;
};

struct KDEVPHPPARSER_EXPORT PrintExpressionAst: public AstNode
{
    enum { KIND = PrintExpressionKind };

    qint64 print;
    AssignmentExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT PropertyTypeAst: public AstNode
{
    enum { KIND = PropertyTypeKind };

    qint64 isNullable;
    PropertyTypeHintAst *typehint;
};

struct KDEVPHPPARSER_EXPORT PropertyTypeHintAst: public AstNode
{
    enum { KIND = PropertyTypeHintKind };

    int callableType;
    NamespacedIdentifierAst *genericType;
    qint64 arrayType;
};

struct KDEVPHPPARSER_EXPORT RelationalExpressionAst: public AstNode
{
    enum { KIND = RelationalExpressionKind };

    ShiftExpressionAst *expression;
    RelationalExpressionRestAst *additionalExpression;
    ClassNameReferenceAst *instanceofType;
};

struct KDEVPHPPARSER_EXPORT RelationalExpressionRestAst: public AstNode
{
    enum { KIND = RelationalExpressionRestKind };

    ShiftExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT ReservedNonModifierIdentifierAst: public AstNode
{
    enum { KIND = ReservedNonModifierIdentifierKind };

    qint64 string;
};

struct KDEVPHPPARSER_EXPORT ReservedNonModifiersAst: public AstNode
{
    enum { KIND = ReservedNonModifiersKind };

};

struct KDEVPHPPARSER_EXPORT ReturnTypeAst: public AstNode
{
    enum { KIND = ReturnTypeKind };

    qint64 isNullable;
    GenericTypeHintAst *typehint;
    qint64 voidType;
};

struct KDEVPHPPARSER_EXPORT ScalarAst: public AstNode
{
    enum { KIND = ScalarKind };

    CommonScalarAst *commonScalar;
    ConstantOrClassConstAst *constantOrClassConst;
    const KDevPG::ListNode<DimListItemAst *> *offsetItemSequence;
    qint64 varname;
    EncapsListAst *encapsList;
    StringIndexSpecifierAst *stringIndex;
};

struct KDEVPHPPARSER_EXPORT SemiReservedAst: public AstNode
{
    enum { KIND = SemiReservedKind };

};

struct KDEVPHPPARSER_EXPORT SemiReservedIdentifierAst: public AstNode
{
    enum { KIND = SemiReservedIdentifierKind };

    qint64 string;
};

struct KDEVPHPPARSER_EXPORT SemicolonOrCloseTagAst: public AstNode
{
    enum { KIND = SemicolonOrCloseTagKind };

};

struct KDEVPHPPARSER_EXPORT ShiftExpressionAst: public AstNode
{
    enum { KIND = ShiftExpressionKind };

    AdditiveExpressionAst *expression;
    const KDevPG::ListNode<ShiftExpressionRestAst *> *additionalExpressionSequence;
};

struct KDEVPHPPARSER_EXPORT ShiftExpressionRestAst: public AstNode
{
    enum { KIND = ShiftExpressionRestKind };

    AdditiveExpressionAst *expression;
};

struct KDEVPHPPARSER_EXPORT StartAst: public AstNode
{
    enum { KIND = StartKind };

    const KDevPG::ListNode<OuterTopStatementAst *> *statementsSequence;
};

struct KDEVPHPPARSER_EXPORT StatementAst: public AstNode
{
    enum { KIND = StatementKind };

    InnerStatementListAst *statements;
    ExprAst *ifExpr;
    StatementAst *ifStatement;
    ElseifListAst *elseifList;
    ElseSingleAst *elseSingle;
    ExprAst *whileExpr;
    WhileStatementAst *whileStatement;
    ForExprAst *forExpr1;
    ForExprAst *forExpr2;
    ForExprAst *forExpr3;
    ForStatementAst *forStatement;
    ExprAst *swtichExpr;
    SwitchCaseListAst *switchCaseList;
    VariableAst *foreachVar;
    ForeachVariableAst *foreachVarAsVar;
    ExprAst *foreachExpr;
    VariableAst *foreachExprAsVar;
    ForeachVariableAst *foreachVariable;
    ForeachStatementAst *foreachStatement;
    DeclareItemAst *declareItem;
    const KDevPG::ListNode<CatchItemAst *> *catchesSequence;
    InnerStatementListAst *finallyBody;
    const KDevPG::ListNode<VariableAst *> *unsetVariablesSequence;
    ExprAst *expr;
    StatementAst *doStatement;
    ExprAst *breakExpr;
    ExprAst *continueExpr;
    ExprAst *returnExpr;
    const KDevPG::ListNode<GlobalVarAst *> *globalVarsSequence;
    const KDevPG::ListNode<StaticVarAst *> *staticVarsSequence;
    const KDevPG::ListNode<ExprAst *> *echoExprsSequence;
    ExprAst *throwExpr;
    const KDevPG::ListNode<ConstantDeclarationAst *> *constsSequence;
    UseStatementAst *useStatement;
    qint64 gotoLabel;
    qint64 gotoTarget;
};

struct KDEVPHPPARSER_EXPORT StaticArrayPairValueAst: public AstNode
{
    enum { KIND = StaticArrayPairValueKind };

    const KDevPG::ListNode<StaticScalarAst *> *val1Sequence;
    const KDevPG::ListNode<StaticScalarAst *> *val2Sequence;
};

struct KDEVPHPPARSER_EXPORT StaticMemberAst: public AstNode
{
    enum { KIND = StaticMemberKind };

    NamespacedIdentifierAst *className;
    StaticPropertyAst *staticProperty;
};

struct KDEVPHPPARSER_EXPORT StaticPropertyAst: public AstNode
{
    enum { KIND = StaticPropertyKind };

    CompoundVariableWithSimpleIndirectReferenceAst *staticProperty;
    const KDevPG::ListNode<DimListItemAst *> *offsetItemsSequence;
};

struct KDEVPHPPARSER_EXPORT StaticScalarAst: public AstNode
{
    enum { KIND = StaticScalarKind };

    CommonScalarAst *value;
    ConstantOrClassConstAst *constantOrClassConst;
    StaticScalarAst *plusValue;
    StaticScalarAst *minusValue;
    qint64 array;
    const KDevPG::ListNode<StaticArrayPairValueAst *> *arrayValuesSequence;
};

struct KDEVPHPPARSER_EXPORT StaticVarAst: public AstNode
{
    enum { KIND = StaticVarKind };

    VariableIdentifierAst *var;
    StaticScalarAst *value;
};

struct KDEVPHPPARSER_EXPORT StringIndexSpecifierAst: public AstNode
{
    enum { KIND = StringIndexSpecifierKind };

    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT SwitchCaseListAst: public AstNode
{
    enum { KIND = SwitchCaseListKind };

    CaseListAst *caseList;
};

struct KDEVPHPPARSER_EXPORT TopStatementAst: public AstNode
{
    enum { KIND = TopStatementKind };

    StatementAst *statement;
    FunctionDeclarationStatementAst *functionDeclaration;
    ClassDeclarationStatementAst *classDeclaration;
    TraitDeclarationStatementAst *traitDeclaration;
    InterfaceDeclarationStatementAst *interfaceDeclaration;
};

struct KDEVPHPPARSER_EXPORT TraitAliasDeclarationAst: public AstNode
{
    enum { KIND = TraitAliasDeclarationKind };

    const KDevPG::ListNode<TraitAliasStatementAst *> *statementsSequence;
};

struct KDEVPHPPARSER_EXPORT TraitAliasIdentifierAst: public AstNode
{
    enum { KIND = TraitAliasIdentifierKind };

    NamespacedIdentifierAst *identifier;
    SemiReservedIdentifierAst *methodIdentifier;
};

struct KDEVPHPPARSER_EXPORT TraitAliasStatementAst: public AstNode
{
    enum { KIND = TraitAliasStatementKind };

    TraitAliasIdentifierAst *importIdentifier;
    TraitVisibilityModifiersAst *modifiers;
    ReservedNonModifierIdentifierAst *aliasNonModifierIdentifier;
    SemiReservedIdentifierAst *aliasIdentifier;
    const KDevPG::ListNode<NamespacedIdentifierAst *> *conflictIdentifierSequence;
};

struct KDEVPHPPARSER_EXPORT TraitDeclarationStatementAst: public AstNode
{
    enum { KIND = TraitDeclarationStatementKind };

    IdentifierAst *traitName;
    ClassBodyAst *body;
};

struct KDEVPHPPARSER_EXPORT TraitVisibilityModifiersAst: public AstNode
{
    enum { KIND = TraitVisibilityModifiersKind };

    unsigned int modifiers;
};

struct KDEVPHPPARSER_EXPORT UnaryExpressionAst: public AstNode
{
    enum { KIND = UnaryExpressionKind };

    CastType castType;
    UnaryExpressionAst *unaryExpression;
    AssignmentListAst *assignmentList;
    ExprAst *expression;
    UnaryExpressionAst *includeExpression;
    UnaryExpressionNotPlusminusAst *unaryExpressionNotPlusminus;
};

struct KDEVPHPPARSER_EXPORT UnaryExpressionNotPlusminusAst: public AstNode
{
    enum { KIND = UnaryExpressionNotPlusminusKind };

    const KDevPG::ListNode<PostprefixOperatorAst *> *prefixOperatorSequence;
    VarExpressionAst *varExpression;
    const KDevPG::ListNode<PostprefixOperatorAst *> *postfixOperatorSequence;
};

struct KDEVPHPPARSER_EXPORT UseNamespaceAst: public AstNode
{
    enum { KIND = UseNamespaceKind };

    NamespacedIdentifierAst *identifier;
    IdentifierAst *aliasIdentifier;
};

struct KDEVPHPPARSER_EXPORT UseStatementAst: public AstNode
{
    enum { KIND = UseStatementKind };

    qint64 useFunction;
    qint64 useConst;
    const KDevPG::ListNode<UseNamespaceAst *> *useNamespaceSequence;
};

struct KDEVPHPPARSER_EXPORT VarExpressionAst: public AstNode
{
    enum { KIND = VarExpressionKind };

    qint64 print;
    AssignmentExpressionAst *printExpression;
    qint64 isGenerator;
    PrintExpressionAst *generatorExpression;
    PrintExpressionAst *generatorValueExpr;
    VariableAst *variable;
    VarExpressionNewObjectAst *newObject;
    VarExpressionNormalAst *varExpressionNormal;
    VarExpressionArrayAst *varExpressionArray;
    ArrayIndexSpecifierAst *arrayIndex;
};

struct KDEVPHPPARSER_EXPORT VarExpressionArrayAst: public AstNode
{
    enum { KIND = VarExpressionArrayKind };

    const KDevPG::ListNode<ArrayPairValueAst *> *arrayValuesSequence;
};

struct KDEVPHPPARSER_EXPORT VarExpressionNewObjectAst: public AstNode
{
    enum { KIND = VarExpressionNewObjectKind };

    ClassNameReferenceAst *classNameReference;
    CtorArgumentsAst *ctor;
};

struct KDEVPHPPARSER_EXPORT VarExpressionNormalAst: public AstNode
{
    enum { KIND = VarExpressionNormalKind };

    IifeSyntaxAst *iife;
    VarExpressionNewObjectAst *newObject;
    const KDevPG::ListNode<InstantiationAccessAst *> *variablePropertiesSequence;
    ExprAst *expression;
    EncapsListAst *encapsList;
    VariableAst *variable;
    ScalarAst *scalar;
    const KDevPG::ListNode<VariableAst *> *issetVariableSequence;
    ExprAst *emptyExpression;
    VarExpressionNormalAst *cloneCar;
    ClosureAst *closure;
};

struct KDEVPHPPARSER_EXPORT VariableAst: public AstNode
{
    enum { KIND = VariableKind };

    BaseVariableWithFunctionCallsAst *var;
    const KDevPG::ListNode<VariableObjectPropertyAst *> *variablePropertiesSequence;
};

struct KDEVPHPPARSER_EXPORT VariableIdentifierAst: public AstNode
{
    enum { KIND = VariableIdentifierKind };

    qint64 variable;
};

struct KDEVPHPPARSER_EXPORT VariableNameAst: public AstNode
{
    enum { KIND = VariableNameKind };

    IdentifierAst *name;
    ExprAst *expr;
};

struct KDEVPHPPARSER_EXPORT VariableObjectPropertyAst: public AstNode
{
    enum { KIND = VariableObjectPropertyKind };

    VariablePropertyAst *variableProperty;
};

struct KDEVPHPPARSER_EXPORT VariablePropertyAst: public AstNode
{
    enum { KIND = VariablePropertyKind };

    VariableAst *variable;
    ObjectPropertyAst *objectProperty;
    qint64 isFunctionCall;
    FunctionCallParameterListAst *parameterList;
    ArrayIndexSpecifierAst *arrayIndex;
};

struct KDEVPHPPARSER_EXPORT VariableWithoutObjectsAst: public AstNode
{
    enum { KIND = VariableWithoutObjectsKind };

    CompoundVariableWithSimpleIndirectReferenceAst *variable;
    const KDevPG::ListNode<DimListItemAst *> *offsetItemsSequence;
};

struct KDEVPHPPARSER_EXPORT WhileStatementAst: public AstNode
{
    enum { KIND = WhileStatementKind };

    StatementAst *statement;
    InnerStatementListAst *statements;
};



} // end of namespace Php

#endif

