create an exhaustive switch interface for node.Node
This commit is contained in:
parent
df2fc21324
commit
475ddeb13c
588
exhaustive.go
Normal file
588
exhaustive.go
Normal file
@ -0,0 +1,588 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/z7zmey/php-parser/node"
|
||||
"github.com/z7zmey/php-parser/node/expr"
|
||||
"github.com/z7zmey/php-parser/node/expr/assign"
|
||||
"github.com/z7zmey/php-parser/node/expr/binary"
|
||||
"github.com/z7zmey/php-parser/node/expr/cast"
|
||||
"github.com/z7zmey/php-parser/node/name"
|
||||
"github.com/z7zmey/php-parser/node/scalar"
|
||||
"github.com/z7zmey/php-parser/node/stmt"
|
||||
)
|
||||
|
||||
// Exuhastive is an interface that makes sure there is a case for every possible
|
||||
// PHP AST node type.
|
||||
type Exhaustive interface {
|
||||
|
||||
// node
|
||||
|
||||
handleNodeRoot(*node.Root) error
|
||||
handleNodeIdentifier(*node.Identifier) error
|
||||
handleNodeParameter(*node.Parameter) error
|
||||
handleNodeNullable(*node.Nullable) error
|
||||
handleNodeArgument(*node.Argument) error
|
||||
handleNodeArgumentList(*node.ArgumentList) error
|
||||
|
||||
// name
|
||||
|
||||
handleNameNamePart(*name.NamePart) error
|
||||
handleNameName(*name.Name) error
|
||||
handleNameFullyQualified(*name.FullyQualified) error
|
||||
handleNameRelative(*name.Relative) error
|
||||
|
||||
// scalar
|
||||
|
||||
handleScalarLnumber(*scalar.Lnumber) error
|
||||
handleScalarDnumber(*scalar.Dnumber) error
|
||||
handleScalarString(*scalar.String) error
|
||||
handleScalarEncapsedStringPart(*scalar.EncapsedStringPart) error
|
||||
handleScalarEncapsed(*scalar.Encapsed) error
|
||||
handleScalarHeredoc(*scalar.Heredoc) error
|
||||
handleScalarMagicConstant(*scalar.MagicConstant) error
|
||||
|
||||
// assign
|
||||
|
||||
handleAssign(*assign.Assign) error
|
||||
handleAssignReference(*assign.Reference) error
|
||||
handleAssignBitwiseAnd(*assign.BitwiseAnd) error
|
||||
handleAssignBitwiseOr(*assign.BitwiseOr) error
|
||||
handleAssignBitwiseXor(*assign.BitwiseXor) error
|
||||
handleAssignCoalesce(*assign.Coalesce) error
|
||||
handleAssignConcat(*assign.Concat) error
|
||||
handleAssignDiv(*assign.Div) error
|
||||
handleAssignMinus(*assign.Minus) error
|
||||
handleAssignMod(*assign.Mod) error
|
||||
handleAssignMul(*assign.Mul) error
|
||||
handleAssignPlus(*assign.Plus) error
|
||||
handleAssignPow(*assign.Pow) error
|
||||
handleAssignShiftLeft(*assign.ShiftLeft) error
|
||||
handleAssignShiftRight(*assign.ShiftRight) error
|
||||
|
||||
// binary
|
||||
|
||||
handleBinaryBitwiseAnd(*binary.BitwiseAnd) error
|
||||
handleBinaryBitwiseOr(*binary.BitwiseOr) error
|
||||
handleBinaryBitwiseXor(*binary.BitwiseXor) error
|
||||
handleBinaryBooleanAnd(*binary.BooleanAnd) error
|
||||
handleBinaryBooleanOr(*binary.BooleanOr) error
|
||||
handleBinaryCoalesce(*binary.Coalesce) error
|
||||
handleBinaryConcat(*binary.Concat) error
|
||||
handleBinaryDiv(*binary.Div) error
|
||||
handleBinaryEqual(*binary.Equal) error
|
||||
handleBinaryGreaterOrEqual(*binary.GreaterOrEqual) error
|
||||
handleBinaryGreater(*binary.Greater) error
|
||||
handleBinaryIdentical(*binary.Identical) error
|
||||
handleBinaryLogicalAnd(*binary.LogicalAnd) error
|
||||
handleBinaryLogicalOr(*binary.LogicalOr) error
|
||||
handleBinaryLogicalXor(*binary.LogicalXor) error
|
||||
handleBinaryMinus(*binary.Minus) error
|
||||
handleBinaryMod(*binary.Mod) error
|
||||
handleBinaryMul(*binary.Mul) error
|
||||
handleBinaryNotEqual(*binary.NotEqual) error
|
||||
handleBinaryNotIdentical(*binary.NotIdentical) error
|
||||
handleBinaryPlus(*binary.Plus) error
|
||||
handleBinaryPow(*binary.Pow) error
|
||||
handleBinaryShiftLeft(*binary.ShiftLeft) error
|
||||
handleBinaryShiftRight(*binary.ShiftRight) error
|
||||
handleBinarySmallerOrEqual(*binary.SmallerOrEqual) error
|
||||
handleBinarySmaller(*binary.Smaller) error
|
||||
handleBinarySpaceship(*binary.Spaceship) error
|
||||
|
||||
// cast
|
||||
|
||||
handleCastArray(*cast.Array) error
|
||||
handleCastBool(*cast.Bool) error
|
||||
handleCastDouble(*cast.Double) error
|
||||
handleCastInt(*cast.Int) error
|
||||
handleCastObject(*cast.Object) error
|
||||
handleCastString(*cast.String) error
|
||||
handleCastUnset(*cast.Unset) error
|
||||
|
||||
// expr
|
||||
|
||||
handleExprArrayDimFetch(*expr.ArrayDimFetch) error
|
||||
handleExprArrayItem(*expr.ArrayItem) error
|
||||
handleExprArray(*expr.Array) error
|
||||
handleExprArrowFunction(*expr.ArrowFunction) error
|
||||
handleExprBitwiseNot(*expr.BitwiseNot) error
|
||||
handleExprBooleanNot(*expr.BooleanNot) error
|
||||
handleExprClassConstFetch(*expr.ClassConstFetch) error
|
||||
handleExprClone(*expr.Clone) error
|
||||
handleExprClosureUse(*expr.ClosureUse) error
|
||||
handleExprClosure(*expr.Closure) error
|
||||
handleExprConstFetch(*expr.ConstFetch) error
|
||||
handleExprEmpty(*expr.Empty) error
|
||||
handleExprErrorSuppress(*expr.ErrorSuppress) error
|
||||
handleExprEval(*expr.Eval) error
|
||||
handleExprExit(*expr.Exit) error
|
||||
handleExprFunctionCall(*expr.FunctionCall) error
|
||||
handleExprInclude(*expr.Include) error
|
||||
handleExprIncludeOnce(*expr.IncludeOnce) error
|
||||
handleExprInstanceOf(*expr.InstanceOf) error
|
||||
handleExprIsset(*expr.Isset) error
|
||||
handleExprList(*expr.List) error
|
||||
handleExprMethodCall(*expr.MethodCall) error
|
||||
handleExprNew(*expr.New) error
|
||||
handleExprPostDec(*expr.PostDec) error
|
||||
handleExprPostInc(*expr.PostInc) error
|
||||
handleExprPreDec(*expr.PreDec) error
|
||||
handleExprPreInc(*expr.PreInc) error
|
||||
handleExprPrint(*expr.Print) error
|
||||
handleExprPropertyFetch(*expr.PropertyFetch) error
|
||||
handleExprReference(*expr.Reference) error
|
||||
handleExprRequire(*expr.Require) error
|
||||
handleExprRequireOnce(*expr.RequireOnce) error
|
||||
handleExprShellExec(*expr.ShellExec) error
|
||||
handleExprShortArray(*expr.ShortArray) error
|
||||
handleExprShortList(*expr.ShortList) error
|
||||
handleExprStaticCall(*expr.StaticCall) error
|
||||
handleExprStaticPropertyFetch(*expr.StaticPropertyFetch) error
|
||||
handleExprTernary(*expr.Ternary) error
|
||||
handleExprUnaryMinus(*expr.UnaryMinus) error
|
||||
handleExprUnaryPlus(*expr.UnaryPlus) error
|
||||
handleExprVariable(*expr.Variable) error
|
||||
handleExprYieldFrom(*expr.YieldFrom) error
|
||||
handleExprYield(*expr.Yield) error
|
||||
|
||||
// stmt
|
||||
// grep -Ri 'struct {' stmt/* | sed -re 's/.*type (.+) struct.*/*stmt.\1/' | sort
|
||||
|
||||
handleStmtAltElse(*stmt.AltElse) error
|
||||
handleStmtAltElseIf(*stmt.AltElseIf) error
|
||||
handleStmtAltFor(*stmt.AltFor) error
|
||||
handleStmtAltForeach(*stmt.AltForeach) error
|
||||
handleStmtAltIf(*stmt.AltIf) error
|
||||
handleStmtAltSwitch(*stmt.AltSwitch) error
|
||||
handleStmtAltWhile(*stmt.AltWhile) error
|
||||
handleStmtBreak(*stmt.Break) error
|
||||
handleStmtCase(*stmt.Case) error
|
||||
handleStmtCaseList(*stmt.CaseList) error
|
||||
handleStmtCatch(*stmt.Catch) error
|
||||
handleStmtClass(*stmt.Class) error
|
||||
handleStmtClassExtends(*stmt.ClassExtends) error
|
||||
handleStmtClassImplements(*stmt.ClassImplements) error
|
||||
handleStmtClassMethod(*stmt.ClassMethod) error
|
||||
handleStmtClassConstList(*stmt.ClassConstList) error
|
||||
handleStmtConstList(*stmt.ConstList) error
|
||||
handleStmtConstant(*stmt.Constant) error
|
||||
handleStmtContinue(*stmt.Continue) error
|
||||
handleStmtDeclare(*stmt.Declare) error
|
||||
handleStmtDefault(*stmt.Default) error
|
||||
handleStmtDo(*stmt.Do) error
|
||||
handleStmtEcho(*stmt.Echo) error
|
||||
handleStmtElseIf(*stmt.ElseIf) error
|
||||
handleStmtElse(*stmt.Else) error
|
||||
handleStmtExpression(*stmt.Expression) error
|
||||
handleStmtFinally(*stmt.Finally) error
|
||||
handleStmtFor(*stmt.For) error
|
||||
handleStmtForeach(*stmt.Foreach) error
|
||||
handleStmtFunction(*stmt.Function) error
|
||||
handleStmtGlobal(*stmt.Global) error
|
||||
handleStmtGoto(*stmt.Goto) error
|
||||
handleStmtGroupUse(*stmt.GroupUse) error
|
||||
handleStmtHaltCompiler(*stmt.HaltCompiler) error
|
||||
handleStmtIf(*stmt.If) error
|
||||
handleStmtInlineHtml(*stmt.InlineHtml) error
|
||||
handleStmtInterface(*stmt.Interface) error
|
||||
handleStmtInterfaceExtends(*stmt.InterfaceExtends) error
|
||||
handleStmtLabel(*stmt.Label) error
|
||||
handleStmtNamespace(*stmt.Namespace) error
|
||||
handleStmtNop(*stmt.Nop) error
|
||||
handleStmtPropertyList(*stmt.PropertyList) error
|
||||
handleStmtProperty(*stmt.Property) error
|
||||
handleStmtReturn(*stmt.Return) error
|
||||
handleStmtStaticVar(*stmt.StaticVar) error
|
||||
handleStmtStatic(*stmt.Static) error
|
||||
handleStmtStmtList(*stmt.StmtList) error
|
||||
handleStmtSwitch(*stmt.Switch) error
|
||||
handleStmtThrow(*stmt.Throw) error
|
||||
handleStmtTraitAdaptationList(*stmt.TraitAdaptationList) error
|
||||
handleStmtTraitMethodRef(*stmt.TraitMethodRef) error
|
||||
handleStmtTraitUseAlias(*stmt.TraitUseAlias) error
|
||||
handleStmtTraitUsePrecedence(*stmt.TraitUsePrecedence) error
|
||||
handleStmtTraitUse(*stmt.TraitUse) error
|
||||
handleStmtTrait(*stmt.Trait) error
|
||||
handleStmtTry(*stmt.Try) error
|
||||
handleStmtUnset(*stmt.Unset) error
|
||||
handleStmtUseList(*stmt.UseList) error
|
||||
handleStmtUse(*stmt.Use) error
|
||||
handleStmtWhile(*stmt.While) error
|
||||
}
|
||||
|
||||
func switchExhaustive(e Exhaustive, n_ *node.Node) error {
|
||||
n := *n_ // no copy
|
||||
|
||||
switch n := n.(type) {
|
||||
|
||||
// node
|
||||
|
||||
case *node.Argument:
|
||||
return e.handleNodeArgument(n)
|
||||
case *node.ArgumentList:
|
||||
return e.handleNodeArgumentList(n)
|
||||
case *node.Identifier:
|
||||
return e.handleNodeIdentifier(n)
|
||||
case *node.Nullable:
|
||||
return e.handleNodeNullable(n)
|
||||
case *node.Parameter:
|
||||
return e.handleNodeParameter(n)
|
||||
case *node.Root:
|
||||
return e.handleNodeRoot(n)
|
||||
|
||||
// name
|
||||
|
||||
case *name.FullyQualified:
|
||||
return e.handleNameFullyQualified(n)
|
||||
case *name.Name:
|
||||
return e.handleNameName(n)
|
||||
case *name.NamePart:
|
||||
return e.handleNameNamePart(n)
|
||||
// case *name.Names: // that's an interface
|
||||
case *name.Relative:
|
||||
return e.handleNameRelative(n)
|
||||
|
||||
// scalar
|
||||
|
||||
case *scalar.Dnumber:
|
||||
return e.handleScalarDnumber(n)
|
||||
case *scalar.Encapsed:
|
||||
return e.handleScalarEncapsed(n)
|
||||
case *scalar.EncapsedStringPart:
|
||||
return e.handleScalarEncapsedStringPart(n)
|
||||
case *scalar.Heredoc:
|
||||
return e.handleScalarHeredoc(n)
|
||||
case *scalar.Lnumber:
|
||||
return e.handleScalarLnumber(n)
|
||||
case *scalar.MagicConstant:
|
||||
return e.handleScalarMagicConstant(n)
|
||||
case *scalar.String:
|
||||
return e.handleScalarString(n)
|
||||
|
||||
// assign
|
||||
|
||||
case *assign.Assign:
|
||||
return e.handleAssign(n)
|
||||
case *assign.BitwiseAnd:
|
||||
return e.handleAssignBitwiseAnd(n)
|
||||
case *assign.BitwiseOr:
|
||||
return e.handleAssignBitwiseOr(n)
|
||||
case *assign.BitwiseXor:
|
||||
return e.handleAssignBitwiseXor(n)
|
||||
case *assign.Coalesce:
|
||||
return e.handleAssignCoalesce(n)
|
||||
case *assign.Concat:
|
||||
return e.handleAssignConcat(n)
|
||||
case *assign.Div:
|
||||
return e.handleAssignDiv(n)
|
||||
case *assign.Minus:
|
||||
return e.handleAssignMinus(n)
|
||||
case *assign.Mod:
|
||||
return e.handleAssignMod(n)
|
||||
case *assign.Mul:
|
||||
return e.handleAssignMul(n)
|
||||
case *assign.Plus:
|
||||
return e.handleAssignPlus(n)
|
||||
case *assign.Pow:
|
||||
return e.handleAssignPow(n)
|
||||
case *assign.Reference:
|
||||
return e.handleAssignReference(n)
|
||||
case *assign.ShiftLeft:
|
||||
return e.handleAssignShiftLeft(n)
|
||||
case *assign.ShiftRight:
|
||||
return e.handleAssignShiftRight(n)
|
||||
|
||||
// binary
|
||||
|
||||
case *binary.BitwiseAnd:
|
||||
return e.handleBinaryBitwiseAnd(n)
|
||||
case *binary.BitwiseOr:
|
||||
return e.handleBinaryBitwiseOr(n)
|
||||
case *binary.BitwiseXor:
|
||||
return e.handleBinaryBitwiseXor(n)
|
||||
case *binary.BooleanAnd:
|
||||
return e.handleBinaryBooleanAnd(n)
|
||||
case *binary.BooleanOr:
|
||||
return e.handleBinaryBooleanOr(n)
|
||||
case *binary.Coalesce:
|
||||
return e.handleBinaryCoalesce(n)
|
||||
case *binary.Concat:
|
||||
return e.handleBinaryConcat(n)
|
||||
case *binary.Div:
|
||||
return e.handleBinaryDiv(n)
|
||||
case *binary.Equal:
|
||||
return e.handleBinaryEqual(n)
|
||||
case *binary.Greater:
|
||||
return e.handleBinaryGreater(n)
|
||||
case *binary.GreaterOrEqual:
|
||||
return e.handleBinaryGreaterOrEqual(n)
|
||||
case *binary.Identical:
|
||||
return e.handleBinaryIdentical(n)
|
||||
case *binary.LogicalAnd:
|
||||
return e.handleBinaryLogicalAnd(n)
|
||||
case *binary.LogicalOr:
|
||||
return e.handleBinaryLogicalOr(n)
|
||||
case *binary.LogicalXor:
|
||||
return e.handleBinaryLogicalXor(n)
|
||||
case *binary.Minus:
|
||||
return e.handleBinaryMinus(n)
|
||||
case *binary.Mod:
|
||||
return e.handleBinaryMod(n)
|
||||
case *binary.Mul:
|
||||
return e.handleBinaryMul(n)
|
||||
case *binary.NotEqual:
|
||||
return e.handleBinaryNotEqual(n)
|
||||
case *binary.NotIdentical:
|
||||
return e.handleBinaryNotIdentical(n)
|
||||
case *binary.Plus:
|
||||
return e.handleBinaryPlus(n)
|
||||
case *binary.Pow:
|
||||
return e.handleBinaryPow(n)
|
||||
case *binary.ShiftLeft:
|
||||
return e.handleBinaryShiftLeft(n)
|
||||
case *binary.ShiftRight:
|
||||
return e.handleBinaryShiftRight(n)
|
||||
case *binary.SmallerOrEqual:
|
||||
return e.handleBinarySmallerOrEqual(n)
|
||||
case *binary.Smaller:
|
||||
return e.handleBinarySmaller(n)
|
||||
case *binary.Spaceship:
|
||||
return e.handleBinarySpaceship(n)
|
||||
|
||||
// cast
|
||||
|
||||
case *cast.Array:
|
||||
return e.handleCastArray(n)
|
||||
case *cast.Bool:
|
||||
return e.handleCastBool(n)
|
||||
case *cast.Double:
|
||||
return e.handleCastDouble(n)
|
||||
case *cast.Int:
|
||||
return e.handleCastInt(n)
|
||||
case *cast.Object:
|
||||
return e.handleCastObject(n)
|
||||
case *cast.String:
|
||||
return e.handleCastString(n)
|
||||
case *cast.Unset:
|
||||
return e.handleCastUnset(n)
|
||||
|
||||
// expr
|
||||
|
||||
case *expr.Array:
|
||||
return e.handleExprArray(n)
|
||||
case *expr.ArrayDimFetch:
|
||||
return e.handleExprArrayDimFetch(n)
|
||||
case *expr.ArrayItem:
|
||||
return e.handleExprArrayItem(n)
|
||||
case *expr.ArrowFunction:
|
||||
return e.handleExprArrowFunction(n)
|
||||
case *expr.BitwiseNot:
|
||||
return e.handleExprBitwiseNot(n)
|
||||
case *expr.BooleanNot:
|
||||
return e.handleExprBooleanNot(n)
|
||||
case *expr.ClassConstFetch:
|
||||
return e.handleExprClassConstFetch(n)
|
||||
case *expr.Clone:
|
||||
return e.handleExprClone(n)
|
||||
case *expr.Closure:
|
||||
return e.handleExprClosure(n)
|
||||
case *expr.ClosureUse:
|
||||
return e.handleExprClosureUse(n)
|
||||
case *expr.ConstFetch:
|
||||
return e.handleExprConstFetch(n)
|
||||
case *expr.Empty:
|
||||
return e.handleExprEmpty(n)
|
||||
case *expr.ErrorSuppress:
|
||||
return e.handleExprErrorSuppress(n)
|
||||
case *expr.Eval:
|
||||
return e.handleExprEval(n)
|
||||
case *expr.Exit:
|
||||
return e.handleExprExit(n)
|
||||
case *expr.FunctionCall:
|
||||
return e.handleExprFunctionCall(n)
|
||||
case *expr.Include:
|
||||
return e.handleExprInclude(n)
|
||||
case *expr.IncludeOnce:
|
||||
return e.handleExprIncludeOnce(n)
|
||||
case *expr.InstanceOf:
|
||||
return e.handleExprInstanceOf(n)
|
||||
case *expr.Isset:
|
||||
return e.handleExprIsset(n)
|
||||
case *expr.List:
|
||||
return e.handleExprList(n)
|
||||
case *expr.MethodCall:
|
||||
return e.handleExprMethodCall(n)
|
||||
case *expr.New:
|
||||
return e.handleExprNew(n)
|
||||
case *expr.PostDec:
|
||||
return e.handleExprPostDec(n)
|
||||
case *expr.PostInc:
|
||||
return e.handleExprPostInc(n)
|
||||
case *expr.PreDec:
|
||||
return e.handleExprPreDec(n)
|
||||
case *expr.PreInc:
|
||||
return e.handleExprPreInc(n)
|
||||
case *expr.Print:
|
||||
return e.handleExprPrint(n)
|
||||
case *expr.PropertyFetch:
|
||||
return e.handleExprPropertyFetch(n)
|
||||
case *expr.Reference:
|
||||
return e.handleExprReference(n)
|
||||
case *expr.Require:
|
||||
return e.handleExprRequire(n)
|
||||
case *expr.RequireOnce:
|
||||
return e.handleExprRequireOnce(n)
|
||||
case *expr.ShellExec:
|
||||
return e.handleExprShellExec(n)
|
||||
case *expr.ShortArray:
|
||||
return e.handleExprShortArray(n)
|
||||
case *expr.ShortList:
|
||||
return e.handleExprShortList(n)
|
||||
case *expr.StaticCall:
|
||||
return e.handleExprStaticCall(n)
|
||||
case *expr.StaticPropertyFetch:
|
||||
return e.handleExprStaticPropertyFetch(n)
|
||||
case *expr.Ternary:
|
||||
return e.handleExprTernary(n)
|
||||
case *expr.UnaryMinus:
|
||||
return e.handleExprUnaryMinus(n)
|
||||
case *expr.UnaryPlus:
|
||||
return e.handleExprUnaryPlus(n)
|
||||
case *expr.Variable:
|
||||
return e.handleExprVariable(n)
|
||||
case *expr.Yield:
|
||||
return e.handleExprYield(n)
|
||||
case *expr.YieldFrom:
|
||||
return e.handleExprYieldFrom(n)
|
||||
|
||||
// stmt
|
||||
|
||||
case *stmt.AltElse:
|
||||
return e.handleStmtAltElse(n)
|
||||
case *stmt.AltElseIf:
|
||||
return e.handleStmtAltElseIf(n)
|
||||
case *stmt.AltFor:
|
||||
return e.handleStmtAltFor(n)
|
||||
case *stmt.AltForeach:
|
||||
return e.handleStmtAltForeach(n)
|
||||
case *stmt.AltIf:
|
||||
return e.handleStmtAltIf(n)
|
||||
case *stmt.AltSwitch:
|
||||
return e.handleStmtAltSwitch(n)
|
||||
case *stmt.AltWhile:
|
||||
return e.handleStmtAltWhile(n)
|
||||
case *stmt.Break:
|
||||
return e.handleStmtBreak(n)
|
||||
case *stmt.Case:
|
||||
return e.handleStmtCase(n)
|
||||
case *stmt.CaseList:
|
||||
return e.handleStmtCaseList(n)
|
||||
case *stmt.Catch:
|
||||
return e.handleStmtCatch(n)
|
||||
case *stmt.Class:
|
||||
return e.handleStmtClass(n)
|
||||
case *stmt.ClassConstList:
|
||||
return e.handleStmtClassConstList(n)
|
||||
case *stmt.ClassExtends:
|
||||
return e.handleStmtClassExtends(n)
|
||||
case *stmt.ClassImplements:
|
||||
return e.handleStmtClassImplements(n)
|
||||
case *stmt.ClassMethod:
|
||||
return e.handleStmtClassMethod(n)
|
||||
case *stmt.Constant:
|
||||
return e.handleStmtConstant(n)
|
||||
case *stmt.ConstList:
|
||||
return e.handleStmtConstList(n)
|
||||
case *stmt.Continue:
|
||||
return e.handleStmtContinue(n)
|
||||
case *stmt.Declare:
|
||||
return e.handleStmtDeclare(n)
|
||||
case *stmt.Default:
|
||||
return e.handleStmtDefault(n)
|
||||
case *stmt.Do:
|
||||
return e.handleStmtDo(n)
|
||||
case *stmt.Echo:
|
||||
return e.handleStmtEcho(n)
|
||||
case *stmt.Else:
|
||||
return e.handleStmtElse(n)
|
||||
case *stmt.ElseIf:
|
||||
return e.handleStmtElseIf(n)
|
||||
case *stmt.Expression:
|
||||
return e.handleStmtExpression(n)
|
||||
case *stmt.Finally:
|
||||
return e.handleStmtFinally(n)
|
||||
case *stmt.For:
|
||||
return e.handleStmtFor(n)
|
||||
case *stmt.Foreach:
|
||||
return e.handleStmtForeach(n)
|
||||
case *stmt.Function:
|
||||
return e.handleStmtFunction(n)
|
||||
case *stmt.Global:
|
||||
return e.handleStmtGlobal(n)
|
||||
case *stmt.Goto:
|
||||
return e.handleStmtGoto(n)
|
||||
case *stmt.GroupUse:
|
||||
return e.handleStmtGroupUse(n)
|
||||
case *stmt.HaltCompiler:
|
||||
return e.handleStmtHaltCompiler(n)
|
||||
case *stmt.If:
|
||||
return e.handleStmtIf(n)
|
||||
case *stmt.InlineHtml:
|
||||
return e.handleStmtInlineHtml(n)
|
||||
case *stmt.Interface:
|
||||
return e.handleStmtInterface(n)
|
||||
case *stmt.InterfaceExtends:
|
||||
return e.handleStmtInterfaceExtends(n)
|
||||
case *stmt.Label:
|
||||
return e.handleStmtLabel(n)
|
||||
case *stmt.Namespace:
|
||||
return e.handleStmtNamespace(n)
|
||||
case *stmt.Nop:
|
||||
return e.handleStmtNop(n)
|
||||
case *stmt.Property:
|
||||
return e.handleStmtProperty(n)
|
||||
case *stmt.PropertyList:
|
||||
return e.handleStmtPropertyList(n)
|
||||
case *stmt.Return:
|
||||
return e.handleStmtReturn(n)
|
||||
case *stmt.Static:
|
||||
return e.handleStmtStatic(n)
|
||||
case *stmt.StaticVar:
|
||||
return e.handleStmtStaticVar(n)
|
||||
case *stmt.StmtList:
|
||||
return e.handleStmtStmtList(n)
|
||||
case *stmt.Switch:
|
||||
return e.handleStmtSwitch(n)
|
||||
case *stmt.Throw:
|
||||
return e.handleStmtThrow(n)
|
||||
case *stmt.Trait:
|
||||
return e.handleStmtTrait(n)
|
||||
case *stmt.TraitAdaptationList:
|
||||
return e.handleStmtTraitAdaptationList(n)
|
||||
case *stmt.TraitMethodRef:
|
||||
return e.handleStmtTraitMethodRef(n)
|
||||
case *stmt.TraitUse:
|
||||
return e.handleStmtTraitUse(n)
|
||||
case *stmt.TraitUseAlias:
|
||||
return e.handleStmtTraitUseAlias(n)
|
||||
case *stmt.TraitUsePrecedence:
|
||||
return e.handleStmtTraitUsePrecedence(n)
|
||||
case *stmt.Try:
|
||||
return e.handleStmtTry(n)
|
||||
case *stmt.Unset:
|
||||
return e.handleStmtUnset(n)
|
||||
case *stmt.Use:
|
||||
return e.handleStmtUse(n)
|
||||
case *stmt.UseList:
|
||||
return e.handleStmtUseList(n)
|
||||
case *stmt.While:
|
||||
return e.handleStmtWhile(n)
|
||||
|
||||
//
|
||||
|
||||
default:
|
||||
panic(fmt.Sprintf("missing exhaustive case for type '%t'", n))
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user