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

package ast

import "github.com/VKCOM/php-parser/pkg/position"

var _ Vertex = &Root{}

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

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

var _ Vertex = &Nullable{}

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

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

var _ Vertex = &Union{}

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

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

var _ Vertex = &Intersection{}

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

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

var _ Vertex = &Parameter{}

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

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

var _ Vertex = &Identifier{}

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

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

var _ Vertex = &Argument{}

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

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

var _ Vertex = &Attribute{}

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

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

var _ Vertex = &AttributeGroup{}

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

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

var _ Vertex = &ScalarDnumber{}

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

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

var _ Vertex = &ScalarEncapsed{}

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

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

var _ Vertex = &ScalarEncapsedStringPart{}

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

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

var _ Vertex = &ScalarEncapsedStringVar{}

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

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

var _ Vertex = &ScalarEncapsedStringBrackets{}

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

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

var _ Vertex = &ScalarHeredoc{}

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

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

var _ Vertex = &ScalarLnumber{}

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

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

var _ Vertex = &ScalarMagicConstant{}

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

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

var _ Vertex = &ScalarString{}

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

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

var _ Vertex = &StmtBreak{}

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

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

var _ Vertex = &StmtCase{}

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

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

var _ Vertex = &StmtCatch{}

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

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

var _ Vertex = &StmtEnum{}

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

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

var _ Vertex = &EnumCase{}

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

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

var _ Vertex = &StmtClass{}

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

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

var _ Vertex = &StmtClassConstList{}

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

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

var _ Vertex = &StmtClassMethod{}

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

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

var _ Vertex = &StmtConstList{}

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

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

var _ Vertex = &StmtConstant{}

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

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

var _ Vertex = &StmtContinue{}

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

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

var _ Vertex = &StmtDeclare{}

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

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

var _ Vertex = &StmtDefault{}

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

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

var _ Vertex = &StmtDo{}

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

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

var _ Vertex = &StmtEcho{}

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

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

var _ Vertex = &StmtElse{}

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

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

var _ Vertex = &StmtElseIf{}

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

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

var _ Vertex = &StmtExpression{}

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

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

var _ Vertex = &StmtFinally{}

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

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

var _ Vertex = &StmtFor{}

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

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

var _ Vertex = &StmtForeach{}

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

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

var _ Vertex = &StmtFunction{}

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

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

var _ Vertex = &StmtGlobal{}

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

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

var _ Vertex = &StmtGoto{}

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

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

var _ Vertex = &StmtHaltCompiler{}

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

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

var _ Vertex = &StmtIf{}

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

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

var _ Vertex = &StmtInlineHtml{}

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

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

var _ Vertex = &StmtInterface{}

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

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

var _ Vertex = &StmtLabel{}

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

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

var _ Vertex = &StmtNamespace{}

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

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

var _ Vertex = &StmtNop{}

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

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

var _ Vertex = &StmtProperty{}

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

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

var _ Vertex = &StmtPropertyList{}

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

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

var _ Vertex = &StmtReturn{}

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

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

var _ Vertex = &StmtStatic{}

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

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

var _ Vertex = &StmtStaticVar{}

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

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

var _ Vertex = &StmtStmtList{}

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

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

var _ Vertex = &StmtSwitch{}

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

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

var _ Vertex = &StmtThrow{}

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

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

var _ Vertex = &StmtTrait{}

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

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

var _ Vertex = &StmtTraitUse{}

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

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

var _ Vertex = &StmtTraitUseAlias{}

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

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

var _ Vertex = &StmtTraitUsePrecedence{}

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

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

var _ Vertex = &StmtTry{}

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

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

var _ Vertex = &StmtUnset{}

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

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

var _ Vertex = &StmtUseList{}

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

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

var _ Vertex = &StmtGroupUseList{}

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

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

var _ Vertex = &StmtUse{}

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

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

var _ Vertex = &StmtWhile{}

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

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

var _ Vertex = &ExprArray{}

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

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

var _ Vertex = &ExprArrayDimFetch{}

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

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

var _ Vertex = &ExprArrayItem{}

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

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

var _ Vertex = &ExprArrowFunction{}

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

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

var _ Vertex = &ExprBitwiseNot{}

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

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

var _ Vertex = &ExprBooleanNot{}

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

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

var _ Vertex = &ExprBrackets{}

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

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

var _ Vertex = &ExprClassConstFetch{}

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

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

var _ Vertex = &ExprClone{}

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

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

var _ Vertex = &ExprClosure{}

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

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

var _ Vertex = &ExprClosureUse{}

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

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

var _ Vertex = &ExprConstFetch{}

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

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

var _ Vertex = &ExprEmpty{}

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

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

var _ Vertex = &ExprErrorSuppress{}

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

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

var _ Vertex = &ExprEval{}

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

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

var _ Vertex = &ExprExit{}

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

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

var _ Vertex = &ExprFunctionCall{}

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

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

var _ Vertex = &ExprInclude{}

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

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

var _ Vertex = &ExprIncludeOnce{}

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

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

var _ Vertex = &ExprInstanceOf{}

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

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

var _ Vertex = &ExprIsset{}

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

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

var _ Vertex = &ExprList{}

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

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

var _ Vertex = &ExprMethodCall{}

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

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

var _ Vertex = &ExprNullsafeMethodCall{}

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

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

var _ Vertex = &ExprNew{}

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

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

var _ Vertex = &ExprPostDec{}

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

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

var _ Vertex = &ExprPostInc{}

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

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

var _ Vertex = &ExprPreDec{}

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

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

var _ Vertex = &ExprPreInc{}

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

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

var _ Vertex = &ExprPrint{}

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

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

var _ Vertex = &ExprPropertyFetch{}

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

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

var _ Vertex = &ExprNullsafePropertyFetch{}

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

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

var _ Vertex = &ExprRequire{}

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

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

var _ Vertex = &ExprRequireOnce{}

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

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

var _ Vertex = &ExprShellExec{}

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

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

var _ Vertex = &ExprStaticCall{}

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

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

var _ Vertex = &ExprStaticPropertyFetch{}

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

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

var _ Vertex = &ExprTernary{}

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

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

var _ Vertex = &ExprUnaryMinus{}

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

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

var _ Vertex = &ExprUnaryPlus{}

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

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

var _ Vertex = &ExprVariable{}

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

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

var _ Vertex = &ExprYield{}

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

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

var _ Vertex = &ExprYieldFrom{}

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

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

var _ Vertex = &ExprCastArray{}

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

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

var _ Vertex = &ExprCastBool{}

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

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

var _ Vertex = &ExprCastDouble{}

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

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

var _ Vertex = &ExprCastInt{}

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

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

var _ Vertex = &ExprCastObject{}

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

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

var _ Vertex = &ExprCastString{}

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

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

var _ Vertex = &ExprCastUnset{}

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

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

var _ Vertex = &ExprAssign{}

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

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

var _ Vertex = &ExprAssignReference{}

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

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

var _ Vertex = &ExprAssignBitwiseAnd{}

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

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

var _ Vertex = &ExprAssignBitwiseOr{}

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

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

var _ Vertex = &ExprAssignBitwiseXor{}

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

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

var _ Vertex = &ExprAssignCoalesce{}

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

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

var _ Vertex = &ExprAssignConcat{}

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

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

var _ Vertex = &ExprAssignDiv{}

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

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

var _ Vertex = &ExprAssignMinus{}

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

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

var _ Vertex = &ExprAssignMod{}

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

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

var _ Vertex = &ExprAssignMul{}

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

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

var _ Vertex = &ExprAssignPlus{}

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

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

var _ Vertex = &ExprAssignPow{}

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

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

var _ Vertex = &ExprAssignShiftLeft{}

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

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

var _ Vertex = &ExprAssignShiftRight{}

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

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

var _ Vertex = &ExprBinaryBitwiseAnd{}

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

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

var _ Vertex = &ExprBinaryBitwiseOr{}

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

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

var _ Vertex = &ExprBinaryBitwiseXor{}

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

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

var _ Vertex = &ExprBinaryBooleanAnd{}

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

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

var _ Vertex = &ExprBinaryBooleanOr{}

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

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

var _ Vertex = &ExprBinaryCoalesce{}

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

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

var _ Vertex = &ExprBinaryConcat{}

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

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

var _ Vertex = &ExprBinaryDiv{}

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

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

var _ Vertex = &ExprBinaryEqual{}

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

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

var _ Vertex = &ExprBinaryGreater{}

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

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

var _ Vertex = &ExprBinaryGreaterOrEqual{}

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

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

var _ Vertex = &ExprBinaryIdentical{}

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

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

var _ Vertex = &ExprBinaryLogicalAnd{}

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

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

var _ Vertex = &ExprBinaryLogicalOr{}

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

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

var _ Vertex = &ExprBinaryLogicalXor{}

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

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

var _ Vertex = &ExprBinaryMinus{}

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

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

var _ Vertex = &ExprBinaryMod{}

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

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

var _ Vertex = &ExprBinaryMul{}

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

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

var _ Vertex = &ExprBinaryNotEqual{}

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

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

var _ Vertex = &ExprBinaryNotIdentical{}

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

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

var _ Vertex = &ExprBinaryPlus{}

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

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

var _ Vertex = &ExprBinaryPow{}

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

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

var _ Vertex = &ExprBinaryShiftLeft{}

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

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

var _ Vertex = &ExprBinaryShiftRight{}

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

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

var _ Vertex = &ExprBinarySmaller{}

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

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

var _ Vertex = &ExprBinarySmallerOrEqual{}

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

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

var _ Vertex = &ExprBinarySpaceship{}

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

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

var _ Vertex = &ExprMatch{}

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

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

var _ Vertex = &ExprThrow{}

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

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

var _ Vertex = &MatchArm{}

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

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

var _ Vertex = &Name{}

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

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

var _ Vertex = &NameFullyQualified{}

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

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

var _ Vertex = &NameRelative{}

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

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

var _ Vertex = &NamePart{}

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

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