// Code generated by "go generate go run node_funcs_gen.go"; DO NOT EDIT.

package ast

import "git.maride.cc/maride/php-parser/pkg/position"

type Type int

const (
    TypeNone Type = iota
    TypeRoot
    TypeNullable
    TypeUnion
    TypeIntersection
    TypeParameter
    TypeIdentifier
    TypeArgument
    TypeAttribute
    TypeAttributeGroup
    TypeScalarDnumber
    TypeScalarEncapsed
    TypeScalarEncapsedStringPart
    TypeScalarEncapsedStringVar
    TypeScalarEncapsedStringBrackets
    TypeScalarHeredoc
    TypeScalarLnumber
    TypeScalarMagicConstant
    TypeScalarString
    TypeStmtBreak
    TypeStmtCase
    TypeStmtCatch
    TypeStmtEnum
    TypeEnumCase
    TypeStmtClass
    TypeStmtClassConstList
    TypeStmtClassMethod
    TypeStmtConstList
    TypeStmtConstant
    TypeStmtContinue
    TypeStmtDeclare
    TypeStmtDefault
    TypeStmtDo
    TypeStmtEcho
    TypeStmtElse
    TypeStmtElseIf
    TypeStmtExpression
    TypeStmtFinally
    TypeStmtFor
    TypeStmtForeach
    TypeStmtFunction
    TypeStmtGlobal
    TypeStmtGoto
    TypeStmtHaltCompiler
    TypeStmtIf
    TypeStmtInlineHtml
    TypeStmtInterface
    TypeStmtLabel
    TypeStmtNamespace
    TypeStmtNop
    TypeStmtProperty
    TypeStmtPropertyList
    TypeStmtReturn
    TypeStmtStatic
    TypeStmtStaticVar
    TypeStmtStmtList
    TypeStmtSwitch
    TypeStmtThrow
    TypeStmtTrait
    TypeStmtTraitUse
    TypeStmtTraitUseAlias
    TypeStmtTraitUsePrecedence
    TypeStmtTry
    TypeStmtUnset
    TypeStmtUseList
    TypeStmtGroupUseList
    TypeStmtUse
    TypeStmtWhile
    TypeExprArray
    TypeExprArrayDimFetch
    TypeExprArrayItem
    TypeExprArrowFunction
    TypeExprBitwiseNot
    TypeExprBooleanNot
    TypeExprBrackets
    TypeExprClassConstFetch
    TypeExprClone
    TypeExprClosure
    TypeExprClosureUse
    TypeExprConstFetch
    TypeExprEmpty
    TypeExprErrorSuppress
    TypeExprEval
    TypeExprExit
    TypeExprFunctionCall
    TypeExprInclude
    TypeExprIncludeOnce
    TypeExprInstanceOf
    TypeExprIsset
    TypeExprList
    TypeExprMethodCall
    TypeExprNullsafeMethodCall
    TypeExprNew
    TypeExprPostDec
    TypeExprPostInc
    TypeExprPreDec
    TypeExprPreInc
    TypeExprPrint
    TypeExprPropertyFetch
    TypeExprNullsafePropertyFetch
    TypeExprRequire
    TypeExprRequireOnce
    TypeExprShellExec
    TypeExprStaticCall
    TypeExprStaticPropertyFetch
    TypeExprTernary
    TypeExprUnaryMinus
    TypeExprUnaryPlus
    TypeExprVariable
    TypeExprYield
    TypeExprYieldFrom
    TypeExprCastArray
    TypeExprCastBool
    TypeExprCastDouble
    TypeExprCastInt
    TypeExprCastObject
    TypeExprCastString
    TypeExprCastUnset
    TypeExprAssign
    TypeExprAssignReference
    TypeExprAssignBitwiseAnd
    TypeExprAssignBitwiseOr
    TypeExprAssignBitwiseXor
    TypeExprAssignCoalesce
    TypeExprAssignConcat
    TypeExprAssignDiv
    TypeExprAssignMinus
    TypeExprAssignMod
    TypeExprAssignMul
    TypeExprAssignPlus
    TypeExprAssignPow
    TypeExprAssignShiftLeft
    TypeExprAssignShiftRight
    TypeExprBinaryBitwiseAnd
    TypeExprBinaryBitwiseOr
    TypeExprBinaryBitwiseXor
    TypeExprBinaryBooleanAnd
    TypeExprBinaryBooleanOr
    TypeExprBinaryCoalesce
    TypeExprBinaryConcat
    TypeExprBinaryDiv
    TypeExprBinaryEqual
    TypeExprBinaryGreater
    TypeExprBinaryGreaterOrEqual
    TypeExprBinaryIdentical
    TypeExprBinaryLogicalAnd
    TypeExprBinaryLogicalOr
    TypeExprBinaryLogicalXor
    TypeExprBinaryMinus
    TypeExprBinaryMod
    TypeExprBinaryMul
    TypeExprBinaryNotEqual
    TypeExprBinaryNotIdentical
    TypeExprBinaryPlus
    TypeExprBinaryPow
    TypeExprBinaryShiftLeft
    TypeExprBinaryShiftRight
    TypeExprBinarySmaller
    TypeExprBinarySmallerOrEqual
    TypeExprBinarySpaceship
    TypeExprMatch
    TypeExprThrow
    TypeMatchArm
    TypeName
    TypeNameFullyQualified
    TypeNameRelative
    TypeNamePart
    TypeCount
)

var _ Vertex = &Root{}

func (n *Root) Accept(v Visitor) {
    v.Root(n)
}

func (n *Root) GetPosition() *position.Position {
    return n.Position
}

func (n *Root) GetType() Type {
    return TypeRoot
}

var _ Vertex = &Nullable{}

func (n *Nullable) Accept(v Visitor) {
    v.Nullable(n)
}

func (n *Nullable) GetPosition() *position.Position {
    return n.Position
}

func (n *Nullable) GetType() Type {
    return TypeNullable
}

var _ Vertex = &Union{}

func (n *Union) Accept(v Visitor) {
    v.Union(n)
}

func (n *Union) GetPosition() *position.Position {
    return n.Position
}

func (n *Union) GetType() Type {
    return TypeUnion
}

var _ Vertex = &Intersection{}

func (n *Intersection) Accept(v Visitor) {
    v.Intersection(n)
}

func (n *Intersection) GetPosition() *position.Position {
    return n.Position
}

func (n *Intersection) GetType() Type {
    return TypeIntersection
}

var _ Vertex = &Parameter{}

func (n *Parameter) Accept(v Visitor) {
    v.Parameter(n)
}

func (n *Parameter) GetPosition() *position.Position {
    return n.Position
}

func (n *Parameter) GetType() Type {
    return TypeParameter
}

var _ Vertex = &Identifier{}

func (n *Identifier) Accept(v Visitor) {
    v.Identifier(n)
}

func (n *Identifier) GetPosition() *position.Position {
    return n.Position
}

func (n *Identifier) GetType() Type {
    return TypeIdentifier
}

var _ Vertex = &Argument{}

func (n *Argument) Accept(v Visitor) {
    v.Argument(n)
}

func (n *Argument) GetPosition() *position.Position {
    return n.Position
}

func (n *Argument) GetType() Type {
    return TypeArgument
}

var _ Vertex = &Attribute{}

func (n *Attribute) Accept(v Visitor) {
    v.Attribute(n)
}

func (n *Attribute) GetPosition() *position.Position {
    return n.Position
}

func (n *Attribute) GetType() Type {
    return TypeAttribute
}

var _ Vertex = &AttributeGroup{}

func (n *AttributeGroup) Accept(v Visitor) {
    v.AttributeGroup(n)
}

func (n *AttributeGroup) GetPosition() *position.Position {
    return n.Position
}

func (n *AttributeGroup) GetType() Type {
    return TypeAttributeGroup
}

var _ Vertex = &ScalarDnumber{}

func (n *ScalarDnumber) Accept(v Visitor) {
    v.ScalarDnumber(n)
}

func (n *ScalarDnumber) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarDnumber) GetType() Type {
    return TypeScalarDnumber
}

var _ Vertex = &ScalarEncapsed{}

func (n *ScalarEncapsed) Accept(v Visitor) {
    v.ScalarEncapsed(n)
}

func (n *ScalarEncapsed) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarEncapsed) GetType() Type {
    return TypeScalarEncapsed
}

var _ Vertex = &ScalarEncapsedStringPart{}

func (n *ScalarEncapsedStringPart) Accept(v Visitor) {
    v.ScalarEncapsedStringPart(n)
}

func (n *ScalarEncapsedStringPart) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarEncapsedStringPart) GetType() Type {
    return TypeScalarEncapsedStringPart
}

var _ Vertex = &ScalarEncapsedStringVar{}

func (n *ScalarEncapsedStringVar) Accept(v Visitor) {
    v.ScalarEncapsedStringVar(n)
}

func (n *ScalarEncapsedStringVar) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarEncapsedStringVar) GetType() Type {
    return TypeScalarEncapsedStringVar
}

var _ Vertex = &ScalarEncapsedStringBrackets{}

func (n *ScalarEncapsedStringBrackets) Accept(v Visitor) {
    v.ScalarEncapsedStringBrackets(n)
}

func (n *ScalarEncapsedStringBrackets) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarEncapsedStringBrackets) GetType() Type {
    return TypeScalarEncapsedStringBrackets
}

var _ Vertex = &ScalarHeredoc{}

func (n *ScalarHeredoc) Accept(v Visitor) {
    v.ScalarHeredoc(n)
}

func (n *ScalarHeredoc) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarHeredoc) GetType() Type {
    return TypeScalarHeredoc
}

var _ Vertex = &ScalarLnumber{}

func (n *ScalarLnumber) Accept(v Visitor) {
    v.ScalarLnumber(n)
}

func (n *ScalarLnumber) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarLnumber) GetType() Type {
    return TypeScalarLnumber
}

var _ Vertex = &ScalarMagicConstant{}

func (n *ScalarMagicConstant) Accept(v Visitor) {
    v.ScalarMagicConstant(n)
}

func (n *ScalarMagicConstant) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarMagicConstant) GetType() Type {
    return TypeScalarMagicConstant
}

var _ Vertex = &ScalarString{}

func (n *ScalarString) Accept(v Visitor) {
    v.ScalarString(n)
}

func (n *ScalarString) GetPosition() *position.Position {
    return n.Position
}

func (n *ScalarString) GetType() Type {
    return TypeScalarString
}

var _ Vertex = &StmtBreak{}

func (n *StmtBreak) Accept(v Visitor) {
    v.StmtBreak(n)
}

func (n *StmtBreak) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtBreak) GetType() Type {
    return TypeStmtBreak
}

var _ Vertex = &StmtCase{}

func (n *StmtCase) Accept(v Visitor) {
    v.StmtCase(n)
}

func (n *StmtCase) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtCase) GetType() Type {
    return TypeStmtCase
}

var _ Vertex = &StmtCatch{}

func (n *StmtCatch) Accept(v Visitor) {
    v.StmtCatch(n)
}

func (n *StmtCatch) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtCatch) GetType() Type {
    return TypeStmtCatch
}

var _ Vertex = &StmtEnum{}

func (n *StmtEnum) Accept(v Visitor) {
    v.StmtEnum(n)
}

func (n *StmtEnum) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtEnum) GetType() Type {
    return TypeStmtEnum
}

var _ Vertex = &EnumCase{}

func (n *EnumCase) Accept(v Visitor) {
    v.EnumCase(n)
}

func (n *EnumCase) GetPosition() *position.Position {
    return n.Position
}

func (n *EnumCase) GetType() Type {
    return TypeEnumCase
}

var _ Vertex = &StmtClass{}

func (n *StmtClass) Accept(v Visitor) {
    v.StmtClass(n)
}

func (n *StmtClass) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtClass) GetType() Type {
    return TypeStmtClass
}

var _ Vertex = &StmtClassConstList{}

func (n *StmtClassConstList) Accept(v Visitor) {
    v.StmtClassConstList(n)
}

func (n *StmtClassConstList) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtClassConstList) GetType() Type {
    return TypeStmtClassConstList
}

var _ Vertex = &StmtClassMethod{}

func (n *StmtClassMethod) Accept(v Visitor) {
    v.StmtClassMethod(n)
}

func (n *StmtClassMethod) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtClassMethod) GetType() Type {
    return TypeStmtClassMethod
}

var _ Vertex = &StmtConstList{}

func (n *StmtConstList) Accept(v Visitor) {
    v.StmtConstList(n)
}

func (n *StmtConstList) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtConstList) GetType() Type {
    return TypeStmtConstList
}

var _ Vertex = &StmtConstant{}

func (n *StmtConstant) Accept(v Visitor) {
    v.StmtConstant(n)
}

func (n *StmtConstant) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtConstant) GetType() Type {
    return TypeStmtConstant
}

var _ Vertex = &StmtContinue{}

func (n *StmtContinue) Accept(v Visitor) {
    v.StmtContinue(n)
}

func (n *StmtContinue) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtContinue) GetType() Type {
    return TypeStmtContinue
}

var _ Vertex = &StmtDeclare{}

func (n *StmtDeclare) Accept(v Visitor) {
    v.StmtDeclare(n)
}

func (n *StmtDeclare) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtDeclare) GetType() Type {
    return TypeStmtDeclare
}

var _ Vertex = &StmtDefault{}

func (n *StmtDefault) Accept(v Visitor) {
    v.StmtDefault(n)
}

func (n *StmtDefault) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtDefault) GetType() Type {
    return TypeStmtDefault
}

var _ Vertex = &StmtDo{}

func (n *StmtDo) Accept(v Visitor) {
    v.StmtDo(n)
}

func (n *StmtDo) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtDo) GetType() Type {
    return TypeStmtDo
}

var _ Vertex = &StmtEcho{}

func (n *StmtEcho) Accept(v Visitor) {
    v.StmtEcho(n)
}

func (n *StmtEcho) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtEcho) GetType() Type {
    return TypeStmtEcho
}

var _ Vertex = &StmtElse{}

func (n *StmtElse) Accept(v Visitor) {
    v.StmtElse(n)
}

func (n *StmtElse) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtElse) GetType() Type {
    return TypeStmtElse
}

var _ Vertex = &StmtElseIf{}

func (n *StmtElseIf) Accept(v Visitor) {
    v.StmtElseIf(n)
}

func (n *StmtElseIf) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtElseIf) GetType() Type {
    return TypeStmtElseIf
}

var _ Vertex = &StmtExpression{}

func (n *StmtExpression) Accept(v Visitor) {
    v.StmtExpression(n)
}

func (n *StmtExpression) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtExpression) GetType() Type {
    return TypeStmtExpression
}

var _ Vertex = &StmtFinally{}

func (n *StmtFinally) Accept(v Visitor) {
    v.StmtFinally(n)
}

func (n *StmtFinally) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtFinally) GetType() Type {
    return TypeStmtFinally
}

var _ Vertex = &StmtFor{}

func (n *StmtFor) Accept(v Visitor) {
    v.StmtFor(n)
}

func (n *StmtFor) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtFor) GetType() Type {
    return TypeStmtFor
}

var _ Vertex = &StmtForeach{}

func (n *StmtForeach) Accept(v Visitor) {
    v.StmtForeach(n)
}

func (n *StmtForeach) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtForeach) GetType() Type {
    return TypeStmtForeach
}

var _ Vertex = &StmtFunction{}

func (n *StmtFunction) Accept(v Visitor) {
    v.StmtFunction(n)
}

func (n *StmtFunction) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtFunction) GetType() Type {
    return TypeStmtFunction
}

var _ Vertex = &StmtGlobal{}

func (n *StmtGlobal) Accept(v Visitor) {
    v.StmtGlobal(n)
}

func (n *StmtGlobal) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtGlobal) GetType() Type {
    return TypeStmtGlobal
}

var _ Vertex = &StmtGoto{}

func (n *StmtGoto) Accept(v Visitor) {
    v.StmtGoto(n)
}

func (n *StmtGoto) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtGoto) GetType() Type {
    return TypeStmtGoto
}

var _ Vertex = &StmtHaltCompiler{}

func (n *StmtHaltCompiler) Accept(v Visitor) {
    v.StmtHaltCompiler(n)
}

func (n *StmtHaltCompiler) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtHaltCompiler) GetType() Type {
    return TypeStmtHaltCompiler
}

var _ Vertex = &StmtIf{}

func (n *StmtIf) Accept(v Visitor) {
    v.StmtIf(n)
}

func (n *StmtIf) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtIf) GetType() Type {
    return TypeStmtIf
}

var _ Vertex = &StmtInlineHtml{}

func (n *StmtInlineHtml) Accept(v Visitor) {
    v.StmtInlineHtml(n)
}

func (n *StmtInlineHtml) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtInlineHtml) GetType() Type {
    return TypeStmtInlineHtml
}

var _ Vertex = &StmtInterface{}

func (n *StmtInterface) Accept(v Visitor) {
    v.StmtInterface(n)
}

func (n *StmtInterface) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtInterface) GetType() Type {
    return TypeStmtInterface
}

var _ Vertex = &StmtLabel{}

func (n *StmtLabel) Accept(v Visitor) {
    v.StmtLabel(n)
}

func (n *StmtLabel) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtLabel) GetType() Type {
    return TypeStmtLabel
}

var _ Vertex = &StmtNamespace{}

func (n *StmtNamespace) Accept(v Visitor) {
    v.StmtNamespace(n)
}

func (n *StmtNamespace) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtNamespace) GetType() Type {
    return TypeStmtNamespace
}

var _ Vertex = &StmtNop{}

func (n *StmtNop) Accept(v Visitor) {
    v.StmtNop(n)
}

func (n *StmtNop) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtNop) GetType() Type {
    return TypeStmtNop
}

var _ Vertex = &StmtProperty{}

func (n *StmtProperty) Accept(v Visitor) {
    v.StmtProperty(n)
}

func (n *StmtProperty) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtProperty) GetType() Type {
    return TypeStmtProperty
}

var _ Vertex = &StmtPropertyList{}

func (n *StmtPropertyList) Accept(v Visitor) {
    v.StmtPropertyList(n)
}

func (n *StmtPropertyList) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtPropertyList) GetType() Type {
    return TypeStmtPropertyList
}

var _ Vertex = &StmtReturn{}

func (n *StmtReturn) Accept(v Visitor) {
    v.StmtReturn(n)
}

func (n *StmtReturn) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtReturn) GetType() Type {
    return TypeStmtReturn
}

var _ Vertex = &StmtStatic{}

func (n *StmtStatic) Accept(v Visitor) {
    v.StmtStatic(n)
}

func (n *StmtStatic) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtStatic) GetType() Type {
    return TypeStmtStatic
}

var _ Vertex = &StmtStaticVar{}

func (n *StmtStaticVar) Accept(v Visitor) {
    v.StmtStaticVar(n)
}

func (n *StmtStaticVar) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtStaticVar) GetType() Type {
    return TypeStmtStaticVar
}

var _ Vertex = &StmtStmtList{}

func (n *StmtStmtList) Accept(v Visitor) {
    v.StmtStmtList(n)
}

func (n *StmtStmtList) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtStmtList) GetType() Type {
    return TypeStmtStmtList
}

var _ Vertex = &StmtSwitch{}

func (n *StmtSwitch) Accept(v Visitor) {
    v.StmtSwitch(n)
}

func (n *StmtSwitch) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtSwitch) GetType() Type {
    return TypeStmtSwitch
}

var _ Vertex = &StmtThrow{}

func (n *StmtThrow) Accept(v Visitor) {
    v.StmtThrow(n)
}

func (n *StmtThrow) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtThrow) GetType() Type {
    return TypeStmtThrow
}

var _ Vertex = &StmtTrait{}

func (n *StmtTrait) Accept(v Visitor) {
    v.StmtTrait(n)
}

func (n *StmtTrait) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtTrait) GetType() Type {
    return TypeStmtTrait
}

var _ Vertex = &StmtTraitUse{}

func (n *StmtTraitUse) Accept(v Visitor) {
    v.StmtTraitUse(n)
}

func (n *StmtTraitUse) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtTraitUse) GetType() Type {
    return TypeStmtTraitUse
}

var _ Vertex = &StmtTraitUseAlias{}

func (n *StmtTraitUseAlias) Accept(v Visitor) {
    v.StmtTraitUseAlias(n)
}

func (n *StmtTraitUseAlias) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtTraitUseAlias) GetType() Type {
    return TypeStmtTraitUseAlias
}

var _ Vertex = &StmtTraitUsePrecedence{}

func (n *StmtTraitUsePrecedence) Accept(v Visitor) {
    v.StmtTraitUsePrecedence(n)
}

func (n *StmtTraitUsePrecedence) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtTraitUsePrecedence) GetType() Type {
    return TypeStmtTraitUsePrecedence
}

var _ Vertex = &StmtTry{}

func (n *StmtTry) Accept(v Visitor) {
    v.StmtTry(n)
}

func (n *StmtTry) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtTry) GetType() Type {
    return TypeStmtTry
}

var _ Vertex = &StmtUnset{}

func (n *StmtUnset) Accept(v Visitor) {
    v.StmtUnset(n)
}

func (n *StmtUnset) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtUnset) GetType() Type {
    return TypeStmtUnset
}

var _ Vertex = &StmtUseList{}

func (n *StmtUseList) Accept(v Visitor) {
    v.StmtUse(n)
}

func (n *StmtUseList) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtUseList) GetType() Type {
    return TypeStmtUseList
}

var _ Vertex = &StmtGroupUseList{}

func (n *StmtGroupUseList) Accept(v Visitor) {
    v.StmtGroupUse(n)
}

func (n *StmtGroupUseList) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtGroupUseList) GetType() Type {
    return TypeStmtGroupUseList
}

var _ Vertex = &StmtUse{}

func (n *StmtUse) Accept(v Visitor) {
    v.StmtUseDeclaration(n)
}

func (n *StmtUse) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtUse) GetType() Type {
    return TypeStmtUse
}

var _ Vertex = &StmtWhile{}

func (n *StmtWhile) Accept(v Visitor) {
    v.StmtWhile(n)
}

func (n *StmtWhile) GetPosition() *position.Position {
    return n.Position
}

func (n *StmtWhile) GetType() Type {
    return TypeStmtWhile
}

var _ Vertex = &ExprArray{}

func (n *ExprArray) Accept(v Visitor) {
    v.ExprArray(n)
}

func (n *ExprArray) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprArray) GetType() Type {
    return TypeExprArray
}

var _ Vertex = &ExprArrayDimFetch{}

func (n *ExprArrayDimFetch) Accept(v Visitor) {
    v.ExprArrayDimFetch(n)
}

func (n *ExprArrayDimFetch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprArrayDimFetch) GetType() Type {
    return TypeExprArrayDimFetch
}

var _ Vertex = &ExprArrayItem{}

func (n *ExprArrayItem) Accept(v Visitor) {
    v.ExprArrayItem(n)
}

func (n *ExprArrayItem) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprArrayItem) GetType() Type {
    return TypeExprArrayItem
}

var _ Vertex = &ExprArrowFunction{}

func (n *ExprArrowFunction) Accept(v Visitor) {
    v.ExprArrowFunction(n)
}

func (n *ExprArrowFunction) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprArrowFunction) GetType() Type {
    return TypeExprArrowFunction
}

var _ Vertex = &ExprBitwiseNot{}

func (n *ExprBitwiseNot) Accept(v Visitor) {
    v.ExprBitwiseNot(n)
}

func (n *ExprBitwiseNot) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBitwiseNot) GetType() Type {
    return TypeExprBitwiseNot
}

var _ Vertex = &ExprBooleanNot{}

func (n *ExprBooleanNot) Accept(v Visitor) {
    v.ExprBooleanNot(n)
}

func (n *ExprBooleanNot) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBooleanNot) GetType() Type {
    return TypeExprBooleanNot
}

var _ Vertex = &ExprBrackets{}

func (n *ExprBrackets) Accept(v Visitor) {
    v.ExprBrackets(n)
}

func (n *ExprBrackets) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBrackets) GetType() Type {
    return TypeExprBrackets
}

var _ Vertex = &ExprClassConstFetch{}

func (n *ExprClassConstFetch) Accept(v Visitor) {
    v.ExprClassConstFetch(n)
}

func (n *ExprClassConstFetch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprClassConstFetch) GetType() Type {
    return TypeExprClassConstFetch
}

var _ Vertex = &ExprClone{}

func (n *ExprClone) Accept(v Visitor) {
    v.ExprClone(n)
}

func (n *ExprClone) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprClone) GetType() Type {
    return TypeExprClone
}

var _ Vertex = &ExprClosure{}

func (n *ExprClosure) Accept(v Visitor) {
    v.ExprClosure(n)
}

func (n *ExprClosure) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprClosure) GetType() Type {
    return TypeExprClosure
}

var _ Vertex = &ExprClosureUse{}

func (n *ExprClosureUse) Accept(v Visitor) {
    v.ExprClosureUse(n)
}

func (n *ExprClosureUse) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprClosureUse) GetType() Type {
    return TypeExprClosureUse
}

var _ Vertex = &ExprConstFetch{}

func (n *ExprConstFetch) Accept(v Visitor) {
    v.ExprConstFetch(n)
}

func (n *ExprConstFetch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprConstFetch) GetType() Type {
    return TypeExprConstFetch
}

var _ Vertex = &ExprEmpty{}

func (n *ExprEmpty) Accept(v Visitor) {
    v.ExprEmpty(n)
}

func (n *ExprEmpty) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprEmpty) GetType() Type {
    return TypeExprEmpty
}

var _ Vertex = &ExprErrorSuppress{}

func (n *ExprErrorSuppress) Accept(v Visitor) {
    v.ExprErrorSuppress(n)
}

func (n *ExprErrorSuppress) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprErrorSuppress) GetType() Type {
    return TypeExprErrorSuppress
}

var _ Vertex = &ExprEval{}

func (n *ExprEval) Accept(v Visitor) {
    v.ExprEval(n)
}

func (n *ExprEval) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprEval) GetType() Type {
    return TypeExprEval
}

var _ Vertex = &ExprExit{}

func (n *ExprExit) Accept(v Visitor) {
    v.ExprExit(n)
}

func (n *ExprExit) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprExit) GetType() Type {
    return TypeExprExit
}

var _ Vertex = &ExprFunctionCall{}

func (n *ExprFunctionCall) Accept(v Visitor) {
    v.ExprFunctionCall(n)
}

func (n *ExprFunctionCall) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprFunctionCall) GetType() Type {
    return TypeExprFunctionCall
}

var _ Vertex = &ExprInclude{}

func (n *ExprInclude) Accept(v Visitor) {
    v.ExprInclude(n)
}

func (n *ExprInclude) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprInclude) GetType() Type {
    return TypeExprInclude
}

var _ Vertex = &ExprIncludeOnce{}

func (n *ExprIncludeOnce) Accept(v Visitor) {
    v.ExprIncludeOnce(n)
}

func (n *ExprIncludeOnce) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprIncludeOnce) GetType() Type {
    return TypeExprIncludeOnce
}

var _ Vertex = &ExprInstanceOf{}

func (n *ExprInstanceOf) Accept(v Visitor) {
    v.ExprInstanceOf(n)
}

func (n *ExprInstanceOf) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprInstanceOf) GetType() Type {
    return TypeExprInstanceOf
}

var _ Vertex = &ExprIsset{}

func (n *ExprIsset) Accept(v Visitor) {
    v.ExprIsset(n)
}

func (n *ExprIsset) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprIsset) GetType() Type {
    return TypeExprIsset
}

var _ Vertex = &ExprList{}

func (n *ExprList) Accept(v Visitor) {
    v.ExprList(n)
}

func (n *ExprList) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprList) GetType() Type {
    return TypeExprList
}

var _ Vertex = &ExprMethodCall{}

func (n *ExprMethodCall) Accept(v Visitor) {
    v.ExprMethodCall(n)
}

func (n *ExprMethodCall) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprMethodCall) GetType() Type {
    return TypeExprMethodCall
}

var _ Vertex = &ExprNullsafeMethodCall{}

func (n *ExprNullsafeMethodCall) Accept(v Visitor) {
    v.ExprNullsafeMethodCall(n)
}

func (n *ExprNullsafeMethodCall) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprNullsafeMethodCall) GetType() Type {
    return TypeExprNullsafeMethodCall
}

var _ Vertex = &ExprNew{}

func (n *ExprNew) Accept(v Visitor) {
    v.ExprNew(n)
}

func (n *ExprNew) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprNew) GetType() Type {
    return TypeExprNew
}

var _ Vertex = &ExprPostDec{}

func (n *ExprPostDec) Accept(v Visitor) {
    v.ExprPostDec(n)
}

func (n *ExprPostDec) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprPostDec) GetType() Type {
    return TypeExprPostDec
}

var _ Vertex = &ExprPostInc{}

func (n *ExprPostInc) Accept(v Visitor) {
    v.ExprPostInc(n)
}

func (n *ExprPostInc) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprPostInc) GetType() Type {
    return TypeExprPostInc
}

var _ Vertex = &ExprPreDec{}

func (n *ExprPreDec) Accept(v Visitor) {
    v.ExprPreDec(n)
}

func (n *ExprPreDec) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprPreDec) GetType() Type {
    return TypeExprPreDec
}

var _ Vertex = &ExprPreInc{}

func (n *ExprPreInc) Accept(v Visitor) {
    v.ExprPreInc(n)
}

func (n *ExprPreInc) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprPreInc) GetType() Type {
    return TypeExprPreInc
}

var _ Vertex = &ExprPrint{}

func (n *ExprPrint) Accept(v Visitor) {
    v.ExprPrint(n)
}

func (n *ExprPrint) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprPrint) GetType() Type {
    return TypeExprPrint
}

var _ Vertex = &ExprPropertyFetch{}

func (n *ExprPropertyFetch) Accept(v Visitor) {
    v.ExprPropertyFetch(n)
}

func (n *ExprPropertyFetch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprPropertyFetch) GetType() Type {
    return TypeExprPropertyFetch
}

var _ Vertex = &ExprNullsafePropertyFetch{}

func (n *ExprNullsafePropertyFetch) Accept(v Visitor) {
    v.ExprNullsafePropertyFetch(n)
}

func (n *ExprNullsafePropertyFetch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprNullsafePropertyFetch) GetType() Type {
    return TypeExprNullsafePropertyFetch
}

var _ Vertex = &ExprRequire{}

func (n *ExprRequire) Accept(v Visitor) {
    v.ExprRequire(n)
}

func (n *ExprRequire) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprRequire) GetType() Type {
    return TypeExprRequire
}

var _ Vertex = &ExprRequireOnce{}

func (n *ExprRequireOnce) Accept(v Visitor) {
    v.ExprRequireOnce(n)
}

func (n *ExprRequireOnce) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprRequireOnce) GetType() Type {
    return TypeExprRequireOnce
}

var _ Vertex = &ExprShellExec{}

func (n *ExprShellExec) Accept(v Visitor) {
    v.ExprShellExec(n)
}

func (n *ExprShellExec) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprShellExec) GetType() Type {
    return TypeExprShellExec
}

var _ Vertex = &ExprStaticCall{}

func (n *ExprStaticCall) Accept(v Visitor) {
    v.ExprStaticCall(n)
}

func (n *ExprStaticCall) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprStaticCall) GetType() Type {
    return TypeExprStaticCall
}

var _ Vertex = &ExprStaticPropertyFetch{}

func (n *ExprStaticPropertyFetch) Accept(v Visitor) {
    v.ExprStaticPropertyFetch(n)
}

func (n *ExprStaticPropertyFetch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprStaticPropertyFetch) GetType() Type {
    return TypeExprStaticPropertyFetch
}

var _ Vertex = &ExprTernary{}

func (n *ExprTernary) Accept(v Visitor) {
    v.ExprTernary(n)
}

func (n *ExprTernary) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprTernary) GetType() Type {
    return TypeExprTernary
}

var _ Vertex = &ExprUnaryMinus{}

func (n *ExprUnaryMinus) Accept(v Visitor) {
    v.ExprUnaryMinus(n)
}

func (n *ExprUnaryMinus) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprUnaryMinus) GetType() Type {
    return TypeExprUnaryMinus
}

var _ Vertex = &ExprUnaryPlus{}

func (n *ExprUnaryPlus) Accept(v Visitor) {
    v.ExprUnaryPlus(n)
}

func (n *ExprUnaryPlus) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprUnaryPlus) GetType() Type {
    return TypeExprUnaryPlus
}

var _ Vertex = &ExprVariable{}

func (n *ExprVariable) Accept(v Visitor) {
    v.ExprVariable(n)
}

func (n *ExprVariable) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprVariable) GetType() Type {
    return TypeExprVariable
}

var _ Vertex = &ExprYield{}

func (n *ExprYield) Accept(v Visitor) {
    v.ExprYield(n)
}

func (n *ExprYield) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprYield) GetType() Type {
    return TypeExprYield
}

var _ Vertex = &ExprYieldFrom{}

func (n *ExprYieldFrom) Accept(v Visitor) {
    v.ExprYieldFrom(n)
}

func (n *ExprYieldFrom) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprYieldFrom) GetType() Type {
    return TypeExprYieldFrom
}

var _ Vertex = &ExprCastArray{}

func (n *ExprCastArray) Accept(v Visitor) {
    v.ExprCastArray(n)
}

func (n *ExprCastArray) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastArray) GetType() Type {
    return TypeExprCastArray
}

var _ Vertex = &ExprCastBool{}

func (n *ExprCastBool) Accept(v Visitor) {
    v.ExprCastBool(n)
}

func (n *ExprCastBool) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastBool) GetType() Type {
    return TypeExprCastBool
}

var _ Vertex = &ExprCastDouble{}

func (n *ExprCastDouble) Accept(v Visitor) {
    v.ExprCastDouble(n)
}

func (n *ExprCastDouble) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastDouble) GetType() Type {
    return TypeExprCastDouble
}

var _ Vertex = &ExprCastInt{}

func (n *ExprCastInt) Accept(v Visitor) {
    v.ExprCastInt(n)
}

func (n *ExprCastInt) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastInt) GetType() Type {
    return TypeExprCastInt
}

var _ Vertex = &ExprCastObject{}

func (n *ExprCastObject) Accept(v Visitor) {
    v.ExprCastObject(n)
}

func (n *ExprCastObject) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastObject) GetType() Type {
    return TypeExprCastObject
}

var _ Vertex = &ExprCastString{}

func (n *ExprCastString) Accept(v Visitor) {
    v.ExprCastString(n)
}

func (n *ExprCastString) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastString) GetType() Type {
    return TypeExprCastString
}

var _ Vertex = &ExprCastUnset{}

func (n *ExprCastUnset) Accept(v Visitor) {
    v.ExprCastUnset(n)
}

func (n *ExprCastUnset) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprCastUnset) GetType() Type {
    return TypeExprCastUnset
}

var _ Vertex = &ExprAssign{}

func (n *ExprAssign) Accept(v Visitor) {
    v.ExprAssign(n)
}

func (n *ExprAssign) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssign) GetType() Type {
    return TypeExprAssign
}

var _ Vertex = &ExprAssignReference{}

func (n *ExprAssignReference) Accept(v Visitor) {
    v.ExprAssignReference(n)
}

func (n *ExprAssignReference) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignReference) GetType() Type {
    return TypeExprAssignReference
}

var _ Vertex = &ExprAssignBitwiseAnd{}

func (n *ExprAssignBitwiseAnd) Accept(v Visitor) {
    v.ExprAssignBitwiseAnd(n)
}

func (n *ExprAssignBitwiseAnd) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignBitwiseAnd) GetType() Type {
    return TypeExprAssignBitwiseAnd
}

var _ Vertex = &ExprAssignBitwiseOr{}

func (n *ExprAssignBitwiseOr) Accept(v Visitor) {
    v.ExprAssignBitwiseOr(n)
}

func (n *ExprAssignBitwiseOr) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignBitwiseOr) GetType() Type {
    return TypeExprAssignBitwiseOr
}

var _ Vertex = &ExprAssignBitwiseXor{}

func (n *ExprAssignBitwiseXor) Accept(v Visitor) {
    v.ExprAssignBitwiseXor(n)
}

func (n *ExprAssignBitwiseXor) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignBitwiseXor) GetType() Type {
    return TypeExprAssignBitwiseXor
}

var _ Vertex = &ExprAssignCoalesce{}

func (n *ExprAssignCoalesce) Accept(v Visitor) {
    v.ExprAssignCoalesce(n)
}

func (n *ExprAssignCoalesce) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignCoalesce) GetType() Type {
    return TypeExprAssignCoalesce
}

var _ Vertex = &ExprAssignConcat{}

func (n *ExprAssignConcat) Accept(v Visitor) {
    v.ExprAssignConcat(n)
}

func (n *ExprAssignConcat) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignConcat) GetType() Type {
    return TypeExprAssignConcat
}

var _ Vertex = &ExprAssignDiv{}

func (n *ExprAssignDiv) Accept(v Visitor) {
    v.ExprAssignDiv(n)
}

func (n *ExprAssignDiv) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignDiv) GetType() Type {
    return TypeExprAssignDiv
}

var _ Vertex = &ExprAssignMinus{}

func (n *ExprAssignMinus) Accept(v Visitor) {
    v.ExprAssignMinus(n)
}

func (n *ExprAssignMinus) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignMinus) GetType() Type {
    return TypeExprAssignMinus
}

var _ Vertex = &ExprAssignMod{}

func (n *ExprAssignMod) Accept(v Visitor) {
    v.ExprAssignMod(n)
}

func (n *ExprAssignMod) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignMod) GetType() Type {
    return TypeExprAssignMod
}

var _ Vertex = &ExprAssignMul{}

func (n *ExprAssignMul) Accept(v Visitor) {
    v.ExprAssignMul(n)
}

func (n *ExprAssignMul) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignMul) GetType() Type {
    return TypeExprAssignMul
}

var _ Vertex = &ExprAssignPlus{}

func (n *ExprAssignPlus) Accept(v Visitor) {
    v.ExprAssignPlus(n)
}

func (n *ExprAssignPlus) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignPlus) GetType() Type {
    return TypeExprAssignPlus
}

var _ Vertex = &ExprAssignPow{}

func (n *ExprAssignPow) Accept(v Visitor) {
    v.ExprAssignPow(n)
}

func (n *ExprAssignPow) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignPow) GetType() Type {
    return TypeExprAssignPow
}

var _ Vertex = &ExprAssignShiftLeft{}

func (n *ExprAssignShiftLeft) Accept(v Visitor) {
    v.ExprAssignShiftLeft(n)
}

func (n *ExprAssignShiftLeft) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignShiftLeft) GetType() Type {
    return TypeExprAssignShiftLeft
}

var _ Vertex = &ExprAssignShiftRight{}

func (n *ExprAssignShiftRight) Accept(v Visitor) {
    v.ExprAssignShiftRight(n)
}

func (n *ExprAssignShiftRight) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprAssignShiftRight) GetType() Type {
    return TypeExprAssignShiftRight
}

var _ Vertex = &ExprBinaryBitwiseAnd{}

func (n *ExprBinaryBitwiseAnd) Accept(v Visitor) {
    v.ExprBinaryBitwiseAnd(n)
}

func (n *ExprBinaryBitwiseAnd) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryBitwiseAnd) GetType() Type {
    return TypeExprBinaryBitwiseAnd
}

var _ Vertex = &ExprBinaryBitwiseOr{}

func (n *ExprBinaryBitwiseOr) Accept(v Visitor) {
    v.ExprBinaryBitwiseOr(n)
}

func (n *ExprBinaryBitwiseOr) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryBitwiseOr) GetType() Type {
    return TypeExprBinaryBitwiseOr
}

var _ Vertex = &ExprBinaryBitwiseXor{}

func (n *ExprBinaryBitwiseXor) Accept(v Visitor) {
    v.ExprBinaryBitwiseXor(n)
}

func (n *ExprBinaryBitwiseXor) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryBitwiseXor) GetType() Type {
    return TypeExprBinaryBitwiseXor
}

var _ Vertex = &ExprBinaryBooleanAnd{}

func (n *ExprBinaryBooleanAnd) Accept(v Visitor) {
    v.ExprBinaryBooleanAnd(n)
}

func (n *ExprBinaryBooleanAnd) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryBooleanAnd) GetType() Type {
    return TypeExprBinaryBooleanAnd
}

var _ Vertex = &ExprBinaryBooleanOr{}

func (n *ExprBinaryBooleanOr) Accept(v Visitor) {
    v.ExprBinaryBooleanOr(n)
}

func (n *ExprBinaryBooleanOr) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryBooleanOr) GetType() Type {
    return TypeExprBinaryBooleanOr
}

var _ Vertex = &ExprBinaryCoalesce{}

func (n *ExprBinaryCoalesce) Accept(v Visitor) {
    v.ExprBinaryCoalesce(n)
}

func (n *ExprBinaryCoalesce) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryCoalesce) GetType() Type {
    return TypeExprBinaryCoalesce
}

var _ Vertex = &ExprBinaryConcat{}

func (n *ExprBinaryConcat) Accept(v Visitor) {
    v.ExprBinaryConcat(n)
}

func (n *ExprBinaryConcat) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryConcat) GetType() Type {
    return TypeExprBinaryConcat
}

var _ Vertex = &ExprBinaryDiv{}

func (n *ExprBinaryDiv) Accept(v Visitor) {
    v.ExprBinaryDiv(n)
}

func (n *ExprBinaryDiv) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryDiv) GetType() Type {
    return TypeExprBinaryDiv
}

var _ Vertex = &ExprBinaryEqual{}

func (n *ExprBinaryEqual) Accept(v Visitor) {
    v.ExprBinaryEqual(n)
}

func (n *ExprBinaryEqual) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryEqual) GetType() Type {
    return TypeExprBinaryEqual
}

var _ Vertex = &ExprBinaryGreater{}

func (n *ExprBinaryGreater) Accept(v Visitor) {
    v.ExprBinaryGreater(n)
}

func (n *ExprBinaryGreater) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryGreater) GetType() Type {
    return TypeExprBinaryGreater
}

var _ Vertex = &ExprBinaryGreaterOrEqual{}

func (n *ExprBinaryGreaterOrEqual) Accept(v Visitor) {
    v.ExprBinaryGreaterOrEqual(n)
}

func (n *ExprBinaryGreaterOrEqual) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryGreaterOrEqual) GetType() Type {
    return TypeExprBinaryGreaterOrEqual
}

var _ Vertex = &ExprBinaryIdentical{}

func (n *ExprBinaryIdentical) Accept(v Visitor) {
    v.ExprBinaryIdentical(n)
}

func (n *ExprBinaryIdentical) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryIdentical) GetType() Type {
    return TypeExprBinaryIdentical
}

var _ Vertex = &ExprBinaryLogicalAnd{}

func (n *ExprBinaryLogicalAnd) Accept(v Visitor) {
    v.ExprBinaryLogicalAnd(n)
}

func (n *ExprBinaryLogicalAnd) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryLogicalAnd) GetType() Type {
    return TypeExprBinaryLogicalAnd
}

var _ Vertex = &ExprBinaryLogicalOr{}

func (n *ExprBinaryLogicalOr) Accept(v Visitor) {
    v.ExprBinaryLogicalOr(n)
}

func (n *ExprBinaryLogicalOr) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryLogicalOr) GetType() Type {
    return TypeExprBinaryLogicalOr
}

var _ Vertex = &ExprBinaryLogicalXor{}

func (n *ExprBinaryLogicalXor) Accept(v Visitor) {
    v.ExprBinaryLogicalXor(n)
}

func (n *ExprBinaryLogicalXor) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryLogicalXor) GetType() Type {
    return TypeExprBinaryLogicalXor
}

var _ Vertex = &ExprBinaryMinus{}

func (n *ExprBinaryMinus) Accept(v Visitor) {
    v.ExprBinaryMinus(n)
}

func (n *ExprBinaryMinus) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryMinus) GetType() Type {
    return TypeExprBinaryMinus
}

var _ Vertex = &ExprBinaryMod{}

func (n *ExprBinaryMod) Accept(v Visitor) {
    v.ExprBinaryMod(n)
}

func (n *ExprBinaryMod) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryMod) GetType() Type {
    return TypeExprBinaryMod
}

var _ Vertex = &ExprBinaryMul{}

func (n *ExprBinaryMul) Accept(v Visitor) {
    v.ExprBinaryMul(n)
}

func (n *ExprBinaryMul) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryMul) GetType() Type {
    return TypeExprBinaryMul
}

var _ Vertex = &ExprBinaryNotEqual{}

func (n *ExprBinaryNotEqual) Accept(v Visitor) {
    v.ExprBinaryNotEqual(n)
}

func (n *ExprBinaryNotEqual) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryNotEqual) GetType() Type {
    return TypeExprBinaryNotEqual
}

var _ Vertex = &ExprBinaryNotIdentical{}

func (n *ExprBinaryNotIdentical) Accept(v Visitor) {
    v.ExprBinaryNotIdentical(n)
}

func (n *ExprBinaryNotIdentical) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryNotIdentical) GetType() Type {
    return TypeExprBinaryNotIdentical
}

var _ Vertex = &ExprBinaryPlus{}

func (n *ExprBinaryPlus) Accept(v Visitor) {
    v.ExprBinaryPlus(n)
}

func (n *ExprBinaryPlus) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryPlus) GetType() Type {
    return TypeExprBinaryPlus
}

var _ Vertex = &ExprBinaryPow{}

func (n *ExprBinaryPow) Accept(v Visitor) {
    v.ExprBinaryPow(n)
}

func (n *ExprBinaryPow) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryPow) GetType() Type {
    return TypeExprBinaryPow
}

var _ Vertex = &ExprBinaryShiftLeft{}

func (n *ExprBinaryShiftLeft) Accept(v Visitor) {
    v.ExprBinaryShiftLeft(n)
}

func (n *ExprBinaryShiftLeft) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryShiftLeft) GetType() Type {
    return TypeExprBinaryShiftLeft
}

var _ Vertex = &ExprBinaryShiftRight{}

func (n *ExprBinaryShiftRight) Accept(v Visitor) {
    v.ExprBinaryShiftRight(n)
}

func (n *ExprBinaryShiftRight) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinaryShiftRight) GetType() Type {
    return TypeExprBinaryShiftRight
}

var _ Vertex = &ExprBinarySmaller{}

func (n *ExprBinarySmaller) Accept(v Visitor) {
    v.ExprBinarySmaller(n)
}

func (n *ExprBinarySmaller) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinarySmaller) GetType() Type {
    return TypeExprBinarySmaller
}

var _ Vertex = &ExprBinarySmallerOrEqual{}

func (n *ExprBinarySmallerOrEqual) Accept(v Visitor) {
    v.ExprBinarySmallerOrEqual(n)
}

func (n *ExprBinarySmallerOrEqual) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinarySmallerOrEqual) GetType() Type {
    return TypeExprBinarySmallerOrEqual
}

var _ Vertex = &ExprBinarySpaceship{}

func (n *ExprBinarySpaceship) Accept(v Visitor) {
    v.ExprBinarySpaceship(n)
}

func (n *ExprBinarySpaceship) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprBinarySpaceship) GetType() Type {
    return TypeExprBinarySpaceship
}

var _ Vertex = &ExprMatch{}

func (n *ExprMatch) Accept(v Visitor) {
    v.ExprMatch(n)
}

func (n *ExprMatch) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprMatch) GetType() Type {
    return TypeExprMatch
}

var _ Vertex = &ExprThrow{}

func (n *ExprThrow) Accept(v Visitor) {
    v.ExprThrow(n)
}

func (n *ExprThrow) GetPosition() *position.Position {
    return n.Position
}

func (n *ExprThrow) GetType() Type {
    return TypeExprThrow
}

var _ Vertex = &MatchArm{}

func (n *MatchArm) Accept(v Visitor) {
    v.MatchArm(n)
}

func (n *MatchArm) GetPosition() *position.Position {
    return n.Position
}

func (n *MatchArm) GetType() Type {
    return TypeMatchArm
}

var _ Vertex = &Name{}

func (n *Name) Accept(v Visitor) {
    v.NameName(n)
}

func (n *Name) GetPosition() *position.Position {
    return n.Position
}

func (n *Name) GetType() Type {
    return TypeName
}

var _ Vertex = &NameFullyQualified{}

func (n *NameFullyQualified) Accept(v Visitor) {
    v.NameFullyQualified(n)
}

func (n *NameFullyQualified) GetPosition() *position.Position {
    return n.Position
}

func (n *NameFullyQualified) GetType() Type {
    return TypeNameFullyQualified
}

var _ Vertex = &NameRelative{}

func (n *NameRelative) Accept(v Visitor) {
    v.NameRelative(n)
}

func (n *NameRelative) GetPosition() *position.Position {
    return n.Position
}

func (n *NameRelative) GetType() Type {
    return TypeNameRelative
}

var _ Vertex = &NamePart{}

func (n *NamePart) Accept(v Visitor) {
    v.NameNamePart(n)
}

func (n *NamePart) GetPosition() *position.Position {
    return n.Position
}

func (n *NamePart) GetType() Type {
    return TypeNamePart
}