walk

package

v0.0.16 Latest Latest Go to latest Published: Oct 31, 2022 License: MIT Imports: 5 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/hsiaosiyuan0/mole

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
Variables
func AddAfterListener(ls *Listeners, impl *Listener)
func AddAtomListener(ls *Listeners, impl *Listener)
func AddBeforeListener(ls *Listeners, impl *Listener)
func AddListener(ls *Listeners, t parser.NodeType, impl *Listener) error
func AddNodeAfterListener(ls *Listeners, t parser.NodeType, impl *Listener)
func AddNodeBeforeListener(ls *Listeners, t parser.NodeType, impl *Listener)
func CallListener(t parser.NodeType, n parser.Node, key string, ctx *VisitorCtx)
func CallVisitor(t parser.NodeType, n parser.Node, key string, ctx *VisitorCtx)
func NodeAfterEvent(t parser.NodeType) parser.NodeType
func NodeBeforeEvent(t parser.NodeType) parser.NodeType
func RemoveListener(ls *Listeners, t parser.NodeType, impl *Listener)
func SetVisitor(vs *Visitors, t parser.NodeType, impl Visitor)
func VisitArrLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrLitAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrLitBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrPat(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrPatAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrPatBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrowFn(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrowFnAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitArrowFnBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitAssignExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitAssignExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitAssignExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitAssignPat(node parser.Node, key string, ctx *VisitorCtx)
func VisitAssignPatAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitAssignPatBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitBinExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitBinExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitBinExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitBlockStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitBlockStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitBlockStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitBoolLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitBrkStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitBrkStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitBrkStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitCallExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitCallExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitCallExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitCatch(node parser.Node, key string, ctx *VisitorCtx)
func VisitCatchAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitCatchBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitChainExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitChainExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitChainExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitClassBody(node parser.Node, key string, ctx *VisitorCtx)
func VisitClassBodyAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitClassBodyBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitClassDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitClassDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitClassDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitCondExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitCondExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitCondExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitContStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitContStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitContStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitDebugStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitDecorator(node parser.Node, key string, ctx *VisitorCtx)
func VisitDecoratorAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitDecoratorBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitDoWhileStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitDoWhileStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitDoWhileStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitExportDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitExportDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitExportDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitExportSpec(node parser.Node, key string, ctx *VisitorCtx)
func VisitExportSpecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitExportSpecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitExprStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitExprStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitExprStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitField(node parser.Node, key string, ctx *VisitorCtx)
func VisitFieldAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitFieldBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitFnDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitFnDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitFnDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitForInOfStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitForInOfStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitForInOfStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitForStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitForStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitForStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitIdent(node parser.Node, key string, ctx *VisitorCtx)
func VisitIfStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitIfStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitIfStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportCall(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportCallAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportCallBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportSpec(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportSpecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitImportSpecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxAttr(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxAttrAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxAttrBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxClose(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxCloseAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxCloseBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxElem(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxElemAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxElemBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxEmpty(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxExprSpan(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxExprSpanAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxExprSpanBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxIdent(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxMember(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxMemberAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxMemberBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxNsName(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxOpen(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxOpenAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxOpenBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxSpreadAttr(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxSpreadAttrAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxSpreadAttrBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxSpreadChild(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxSpreadChildAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxSpreadChildBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitJsxText(node parser.Node, key string, ctx *VisitorCtx)
func VisitLabelStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitLabelStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitLabelStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitMemberExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitMemberExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitMemberExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitMetaProp(node parser.Node, key string, ctx *VisitorCtx)
func VisitMetaPropAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitMetaPropBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitMethod(node parser.Node, key string, ctx *VisitorCtx)
func VisitMethodAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitMethodBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitNewExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitNewExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitNewExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitNode(n parser.Node, key string, ctx *VisitorCtx)
func VisitNodes(n parser.Node, ns []parser.Node, key string, ctx *VisitorCtx)
func VisitNodesWithCb(n parser.Node, ns []parser.Node, key string, ctx *VisitorCtx, cb VisitNodesCb)
func VisitNullLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitNumLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitObjLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitObjLitAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitObjLitBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitObjPat(node parser.Node, key string, ctx *VisitorCtx)
func VisitObjPatAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitObjPatBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitParenExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitParenExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitParenExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitProg(node parser.Node, key string, ctx *VisitorCtx)
func VisitProgAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitProgBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitProp(node parser.Node, key string, ctx *VisitorCtx)
func VisitPropAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitPropBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitRegLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitRestPat(node parser.Node, key string, ctx *VisitorCtx)
func VisitRestPatAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitRestPatBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitRetStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitRetStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitRetStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitSeqExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitSeqExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitSeqExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitSpread(node parser.Node, key string, ctx *VisitorCtx)
func VisitSpreadAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitSpreadBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitStaticBlock(node parser.Node, key string, ctx *VisitorCtx)
func VisitStaticBlockAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitStaticBlockBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitStrLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitSuper(node parser.Node, key string, ctx *VisitorCtx)
func VisitSwitchCase(node parser.Node, key string, ctx *VisitorCtx)
func VisitSwitchCaseAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitSwitchCaseBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitSwitchStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitSwitchStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitSwitchStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitThisExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitThrowStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitThrowStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitThrowStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTplExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitTplExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTplExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTryStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitTryStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTryStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsArr(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsArrAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsArrBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsCallSig(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsCallSigAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsCallSigBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsCondType(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsCondTypeAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsCondTypeBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsEnum(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsEnumAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsEnumBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsEnumMember(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsEnumMemberAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsEnumMemberBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsExportAssign(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsExportAssignAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsExportAssignBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsFnTyp(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsFnTypAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsFnTypBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIdxAccess(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIdxAccessAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIdxAccessBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIdxSig(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIdxSigAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIdxSigBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportAlias(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportAliasAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportAliasBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportRequire(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportRequireAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportRequireBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportType(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportTypeAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsImportTypeBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsInterface(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsInterfaceAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsInterfaceBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsInterfaceBody(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsInterfaceBodyAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsInterfaceBodyBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIntersectTyp(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIntersectTypAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsIntersectTypBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsLit(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsLitAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsLitBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsMapped(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsMappedAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsMappedBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNS(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNSAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNSBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNewSig(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNewSigAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNewSigBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNoNull(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNoNullAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNoNullBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNsName(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNsNameAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsNsNameBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsObj(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsObjAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsObjBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsOpt(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsOptAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsOptBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParam(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamsDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamsDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamsDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamsInst(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamsInstAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParamsInstBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParen(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParenAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsParenBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsPredef(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsProp(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsPropAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsPropBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRef(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRefAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRefBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRest(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRestAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRestBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsRoughParam(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsThis(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTuple(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTupleAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTupleBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTupleNamedMember(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTupleNamedMemberAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTupleNamedMemberBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypAnnot(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypAnnotAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypAnnotBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypAssert(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypAssertAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypAssertBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypInfer(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypInferAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypInferBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypOp(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypOpAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypOpBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypPredicate(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypPredicateAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypPredicateBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypQuery(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypQueryAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsTypQueryBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsUnionTyp(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsUnionTypAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitTsUnionTypBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitUnaryExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitUnaryExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitUnaryExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitUpdateExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitUpdateExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitUpdateExprBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitVarDec(node parser.Node, key string, ctx *VisitorCtx)
func VisitVarDecAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitVarDecBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitVarDecStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitVarDecStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitVarDecStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitWhileStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitWhileStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitWhileStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitWithStmt(node parser.Node, key string, ctx *VisitorCtx)
func VisitWithStmtAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitWithStmtBefore(node parser.Node, key string, ctx *VisitorCtx)
func VisitYieldExpr(node parser.Node, key string, ctx *VisitorCtx)
func VisitYieldExprAfter(node parser.Node, key string, ctx *VisitorCtx)
func VisitYieldExprBefore(node parser.Node, key string, ctx *VisitorCtx)
type CondNewScope
type ListenFn
type Listener
type Listeners
type VisitNodesCb
type Visitor
type VisitorCtx
- func (vc *VisitorCtx) ParentIsJmp(key string) bool
- func (vc *VisitorCtx) ParentNode() parser.Node
- func (vc *VisitorCtx) ParentNodeType() parser.NodeType
- func (c *VisitorCtx) Scope() *parser.Scope
- func (c *VisitorCtx) ScopeId() int
type Visitors
type WalkCtx
- func NewWalkCtx(root parser.Node, symtab *parser.SymTab) *WalkCtx
- func (c *WalkCtx) PopScope()
- func (c *WalkCtx) PopVisitorCtx()
- func (c *WalkCtx) PushScope()
- func (c *WalkCtx) PushVisitorCtx(node parser.Node, path string)
- func (c *WalkCtx) Scope() *parser.Scope
- func (c *WalkCtx) ScopeId() int
- func (c *WalkCtx) Stop()
- func (c *WalkCtx) Stopped() bool
- func (c *WalkCtx) VisitorCtx() *VisitorCtx

Constants ¶

View Source

const (
	N_CATCH                 = parser.N_CATCH
	N_CLASS_BODY            = parser.N_CLASS_BODY
	N_DECORATOR             = parser.N_DECORATOR
	N_EXPORT_SPEC           = parser.N_EXPORT_SPEC
	N_EXPR_ARROW            = parser.N_EXPR_ARROW
	N_EXPR_ASSIGN           = parser.N_EXPR_ASSIGN
	N_EXPR_BIN              = parser.N_EXPR_BIN
	N_EXPR_CALL             = parser.N_EXPR_CALL
	N_EXPR_CHAIN            = parser.N_EXPR_CHAIN
	N_EXPR_CLASS            = parser.N_EXPR_CLASS
	N_EXPR_COND             = parser.N_EXPR_COND
	N_EXPR_FN               = parser.N_EXPR_FN
	N_EXPR_MEMBER           = parser.N_EXPR_MEMBER
	N_EXPR_NEW              = parser.N_EXPR_NEW
	N_EXPR_PAREN            = parser.N_EXPR_PAREN
	N_EXPR_SEQ              = parser.N_EXPR_SEQ
	N_EXPR_THIS             = parser.N_EXPR_THIS
	N_EXPR_TPL              = parser.N_EXPR_TPL
	N_EXPR_UNARY            = parser.N_EXPR_UNARY
	N_EXPR_UPDATE           = parser.N_EXPR_UPDATE
	N_EXPR_YIELD            = parser.N_EXPR_YIELD
	N_FIELD                 = parser.N_FIELD
	N_IMPORT_CALL           = parser.N_IMPORT_CALL
	N_IMPORT_SPEC           = parser.N_IMPORT_SPEC
	N_JSX_ATTR              = parser.N_JSX_ATTR
	N_JSX_ATTR_SPREAD       = parser.N_JSX_ATTR_SPREAD
	N_JSX_CHILD_SPREAD      = parser.N_JSX_CHILD_SPREAD
	N_JSX_CLOSE             = parser.N_JSX_CLOSE
	N_JSX_ELEM              = parser.N_JSX_ELEM
	N_JSX_EMPTY             = parser.N_JSX_EMPTY
	N_JSX_EXPR_SPAN         = parser.N_JSX_EXPR_SPAN
	N_JSX_ID                = parser.N_JSX_ID
	N_JSX_MEMBER            = parser.N_JSX_MEMBER
	N_JSX_NS                = parser.N_JSX_NS
	N_JSX_OPEN              = parser.N_JSX_OPEN
	N_JSX_TXT               = parser.N_JSX_TXT
	N_LIT_ARR               = parser.N_LIT_ARR
	N_LIT_BOOL              = parser.N_LIT_BOOL
	N_LIT_NULL              = parser.N_LIT_NULL
	N_LIT_NUM               = parser.N_LIT_NUM
	N_LIT_OBJ               = parser.N_LIT_OBJ
	N_LIT_REGEXP            = parser.N_LIT_REGEXP
	N_LIT_STR               = parser.N_LIT_STR
	N_META_PROP             = parser.N_META_PROP
	N_METHOD                = parser.N_METHOD
	N_NAME                  = parser.N_NAME
	N_PAT_ARRAY             = parser.N_PAT_ARRAY
	N_PAT_ASSIGN            = parser.N_PAT_ASSIGN
	N_PAT_OBJ               = parser.N_PAT_OBJ
	N_PAT_REST              = parser.N_PAT_REST
	N_PROG                  = parser.N_PROG
	N_PROP                  = parser.N_PROP
	N_SPREAD                = parser.N_SPREAD
	N_STATIC_BLOCK          = parser.N_STATIC_BLOCK
	N_STMT_BLOCK            = parser.N_STMT_BLOCK
	N_STMT_BRK              = parser.N_STMT_BRK
	N_STMT_CLASS            = parser.N_STMT_CLASS
	N_STMT_CONT             = parser.N_STMT_CONT
	N_STMT_DEBUG            = parser.N_STMT_DEBUG
	N_STMT_DO_WHILE         = parser.N_STMT_DO_WHILE
	N_STMT_EXPORT           = parser.N_STMT_EXPORT
	N_STMT_EXPR             = parser.N_STMT_EXPR
	N_STMT_FN               = parser.N_STMT_FN
	N_STMT_FOR              = parser.N_STMT_FOR
	N_STMT_FOR_IN_OF        = parser.N_STMT_FOR_IN_OF
	N_STMT_IF               = parser.N_STMT_IF
	N_STMT_IMPORT           = parser.N_STMT_IMPORT
	N_STMT_LABEL            = parser.N_STMT_LABEL
	N_STMT_RET              = parser.N_STMT_RET
	N_STMT_SWITCH           = parser.N_STMT_SWITCH
	N_STMT_THROW            = parser.N_STMT_THROW
	N_STMT_TRY              = parser.N_STMT_TRY
	N_STMT_VAR_DEC          = parser.N_STMT_VAR_DEC
	N_STMT_WHILE            = parser.N_STMT_WHILE
	N_STMT_WITH             = parser.N_STMT_WITH
	N_SUPER                 = parser.N_SUPER
	N_SWITCH_CASE           = parser.N_SWITCH_CASE
	N_TS_ANY                = parser.N_TS_ANY
	N_TS_ARR                = parser.N_TS_ARR
	N_TS_BIGINT             = parser.N_TS_BIGINT
	N_TS_BOOL               = parser.N_TS_BOOL
	N_TS_CALL_SIG           = parser.N_TS_CALL_SIG
	N_TS_COND               = parser.N_TS_COND
	N_TS_DEC_CLASS          = parser.N_TS_DEC_CLASS
	N_TS_DEC_ENUM           = parser.N_TS_DEC_ENUM
	N_TS_DEC_FN             = parser.N_TS_DEC_FN
	N_TS_DEC_GLOBAL         = parser.N_TS_DEC_GLOBAL
	N_TS_DEC_INTERFACE      = parser.N_TS_DEC_INTERFACE
	N_TS_DEC_MODULE         = parser.N_TS_DEC_MODULE
	N_TS_DEC_NS             = parser.N_TS_DEC_NS
	N_TS_DEC_TYP_DEC        = parser.N_TS_DEC_TYP_DEC
	N_TS_DEC_VAR_DEC        = parser.N_TS_DEC_VAR_DEC
	N_TS_ENUM               = parser.N_TS_ENUM
	N_TS_ENUM_MEMBER        = parser.N_TS_ENUM_MEMBER
	N_TS_EXPORT_ASSIGN      = parser.N_TS_EXPORT_ASSIGN
	N_TS_FN_TYP             = parser.N_TS_FN_TYP
	N_TS_IDX_ACCESS         = parser.N_TS_IDX_ACCESS
	N_TS_IDX_SIG            = parser.N_TS_IDX_SIG
	N_TS_IMPORT_ALIAS       = parser.N_TS_IMPORT_ALIAS
	N_TS_IMPORT_REQUIRE     = parser.N_TS_IMPORT_REQUIRE
	N_TS_IMPORT_TYP         = parser.N_TS_IMPORT_TYP
	N_TS_INTERFACE          = parser.N_TS_INTERFACE
	N_TS_INTERFACE_BODY     = parser.N_TS_INTERFACE_BODY
	N_TS_INTERSECT_TYP      = parser.N_TS_INTERSECT_TYP
	N_TS_INTRINSIC          = parser.N_TS_INTRINSIC
	N_TS_LIT                = parser.N_TS_LIT
	N_TS_LIT_OBJ            = parser.N_TS_LIT_OBJ
	N_TS_MAPPED             = parser.N_TS_MAPPED
	N_TS_NAMESPACE          = parser.N_TS_NAMESPACE
	N_TS_NEVER              = parser.N_TS_NEVER
	N_TS_NEW                = parser.N_TS_NEW
	N_TS_NEW_SIG            = parser.N_TS_NEW_SIG
	N_TS_NO_NULL            = parser.N_TS_NO_NULL
	N_TS_NS_NAME            = parser.N_TS_NS_NAME
	N_TS_NULL               = parser.N_TS_NULL
	N_TS_NUM                = parser.N_TS_NUM
	N_TS_OBJ                = parser.N_TS_OBJ
	N_TS_OPT                = parser.N_TS_OPT
	N_TS_PARAM              = parser.N_TS_PARAM
	N_TS_PARAM_DEC          = parser.N_TS_PARAM_DEC
	N_TS_PARAM_INST         = parser.N_TS_PARAM_INST
	N_TS_PAREN              = parser.N_TS_PAREN
	N_TS_PROP               = parser.N_TS_PROP
	N_TS_REF                = parser.N_TS_REF
	N_TS_REST               = parser.N_TS_REST
	N_TS_ROUGH_PARAM        = parser.N_TS_ROUGH_PARAM
	N_TS_STR                = parser.N_TS_STR
	N_TS_SYM                = parser.N_TS_SYM
	N_TS_THIS               = parser.N_TS_THIS
	N_TS_TUPLE              = parser.N_TS_TUPLE
	N_TS_TUPLE_NAMED_MEMBER = parser.N_TS_TUPLE_NAMED_MEMBER
	N_TS_TYP_ANNOT          = parser.N_TS_TYP_ANNOT
	N_TS_TYP_ASSERT         = parser.N_TS_TYP_ASSERT
	N_TS_TYP_DEC            = parser.N_TS_TYP_DEC
	N_TS_TYP_INFER          = parser.N_TS_TYP_INFER
	N_TS_TYP_OP             = parser.N_TS_TYP_OP
	N_TS_TYP_PREDICATE      = parser.N_TS_TYP_PREDICATE
	N_TS_TYP_QUERY          = parser.N_TS_TYP_QUERY
	N_TS_UNDEF              = parser.N_TS_UNDEF
	N_TS_UNION_TYP          = parser.N_TS_UNION_TYP
	N_TS_UNKNOWN            = parser.N_TS_UNKNOWN
	N_TS_VOID               = parser.N_TS_VOID
	N_VAR_DEC               = parser.N_VAR_DEC
)

View Source

const (
	N_BEFORE_AFTER_DEF_BEGIN       = parser.NodeType(parser.N_NODE_DEF_END + iota)
	N_CATCH_BEFORE                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CATCH)*2 - 1
	N_CATCH_AFTER                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CATCH)*2
	N_CLASS_BODY_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CLASS_BODY)*2 - 1
	N_CLASS_BODY_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CLASS_BODY)*2
	N_DECORATOR_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_DECORATOR)*2 - 1
	N_DECORATOR_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_DECORATOR)*2
	N_EXPORT_SPEC_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPORT_SPEC)*2 - 1
	N_EXPORT_SPEC_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPORT_SPEC)*2
	N_EXPR_ARROW_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ARROW)*2 - 1
	N_EXPR_ARROW_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ARROW)*2
	N_EXPR_ASSIGN_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ASSIGN)*2 - 1
	N_EXPR_ASSIGN_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ASSIGN)*2
	N_EXPR_BIN_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_BIN)*2 - 1
	N_EXPR_BIN_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_BIN)*2
	N_EXPR_CALL_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CALL)*2 - 1
	N_EXPR_CALL_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CALL)*2
	N_EXPR_CHAIN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CHAIN)*2 - 1
	N_EXPR_CHAIN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CHAIN)*2
	N_EXPR_CLASS_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CLASS)*2 - 1
	N_EXPR_CLASS_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CLASS)*2
	N_EXPR_COND_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_COND)*2 - 1
	N_EXPR_COND_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_COND)*2
	N_EXPR_FN_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_FN)*2 - 1
	N_EXPR_FN_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_FN)*2
	N_EXPR_MEMBER_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_MEMBER)*2 - 1
	N_EXPR_MEMBER_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_MEMBER)*2
	N_EXPR_NEW_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_NEW)*2 - 1
	N_EXPR_NEW_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_NEW)*2
	N_EXPR_PAREN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_PAREN)*2 - 1
	N_EXPR_PAREN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_PAREN)*2
	N_EXPR_SEQ_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_SEQ)*2 - 1
	N_EXPR_SEQ_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_SEQ)*2
	N_EXPR_THIS_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_THIS)*2 - 1
	N_EXPR_THIS_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_THIS)*2
	N_EXPR_TPL_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_TPL)*2 - 1
	N_EXPR_TPL_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_TPL)*2
	N_EXPR_UNARY_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UNARY)*2 - 1
	N_EXPR_UNARY_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UNARY)*2
	N_EXPR_UPDATE_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UPDATE)*2 - 1
	N_EXPR_UPDATE_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UPDATE)*2
	N_EXPR_YIELD_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_YIELD)*2 - 1
	N_EXPR_YIELD_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_YIELD)*2
	N_FIELD_BEFORE                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_FIELD)*2 - 1
	N_FIELD_AFTER                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_FIELD)*2
	N_IMPORT_CALL_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_CALL)*2 - 1
	N_IMPORT_CALL_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_CALL)*2
	N_IMPORT_SPEC_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_SPEC)*2 - 1
	N_IMPORT_SPEC_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_SPEC)*2
	N_JSX_ATTR_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR)*2 - 1
	N_JSX_ATTR_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR)*2
	N_JSX_ATTR_SPREAD_BEFORE       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR_SPREAD)*2 - 1
	N_JSX_ATTR_SPREAD_AFTER        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR_SPREAD)*2
	N_JSX_CHILD_SPREAD_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CHILD_SPREAD)*2 - 1
	N_JSX_CHILD_SPREAD_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CHILD_SPREAD)*2
	N_JSX_CLOSE_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CLOSE)*2 - 1
	N_JSX_CLOSE_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CLOSE)*2
	N_JSX_ELEM_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ELEM)*2 - 1
	N_JSX_ELEM_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ELEM)*2
	N_JSX_EMPTY_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EMPTY)*2 - 1
	N_JSX_EMPTY_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EMPTY)*2
	N_JSX_EXPR_SPAN_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EXPR_SPAN)*2 - 1
	N_JSX_EXPR_SPAN_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EXPR_SPAN)*2
	N_JSX_ID_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ID)*2 - 1
	N_JSX_ID_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ID)*2
	N_JSX_MEMBER_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_MEMBER)*2 - 1
	N_JSX_MEMBER_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_MEMBER)*2
	N_JSX_NS_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_NS)*2 - 1
	N_JSX_NS_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_NS)*2
	N_JSX_OPEN_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_OPEN)*2 - 1
	N_JSX_OPEN_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_OPEN)*2
	N_JSX_TXT_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_TXT)*2 - 1
	N_JSX_TXT_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_TXT)*2
	N_LIT_ARR_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_ARR)*2 - 1
	N_LIT_ARR_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_ARR)*2
	N_LIT_BOOL_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_BOOL)*2 - 1
	N_LIT_BOOL_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_BOOL)*2
	N_LIT_NULL_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NULL)*2 - 1
	N_LIT_NULL_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NULL)*2
	N_LIT_NUM_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NUM)*2 - 1
	N_LIT_NUM_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NUM)*2
	N_LIT_OBJ_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_OBJ)*2 - 1
	N_LIT_OBJ_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_OBJ)*2
	N_LIT_REGEXP_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_REGEXP)*2 - 1
	N_LIT_REGEXP_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_REGEXP)*2
	N_LIT_STR_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_STR)*2 - 1
	N_LIT_STR_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_STR)*2
	N_META_PROP_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_META_PROP)*2 - 1
	N_META_PROP_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_META_PROP)*2
	N_METHOD_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_METHOD)*2 - 1
	N_METHOD_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_METHOD)*2
	N_NAME_BEFORE                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_NAME)*2 - 1
	N_NAME_AFTER                   = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_NAME)*2
	N_PAT_ARRAY_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ARRAY)*2 - 1
	N_PAT_ARRAY_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ARRAY)*2
	N_PAT_ASSIGN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ASSIGN)*2 - 1
	N_PAT_ASSIGN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ASSIGN)*2
	N_PAT_OBJ_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_OBJ)*2 - 1
	N_PAT_OBJ_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_OBJ)*2
	N_PAT_REST_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_REST)*2 - 1
	N_PAT_REST_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_REST)*2
	N_PROG_BEFORE                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROG)*2 - 1
	N_PROG_AFTER                   = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROG)*2
	N_PROP_BEFORE                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROP)*2 - 1
	N_PROP_AFTER                   = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROP)*2
	N_SPREAD_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SPREAD)*2 - 1
	N_SPREAD_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SPREAD)*2
	N_STATIC_BLOCK_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STATIC_BLOCK)*2 - 1
	N_STATIC_BLOCK_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STATIC_BLOCK)*2
	N_STMT_BLOCK_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BLOCK)*2 - 1
	N_STMT_BLOCK_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BLOCK)*2
	N_STMT_BRK_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BRK)*2 - 1
	N_STMT_BRK_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BRK)*2
	N_STMT_CLASS_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CLASS)*2 - 1
	N_STMT_CLASS_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CLASS)*2
	N_STMT_CONT_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CONT)*2 - 1
	N_STMT_CONT_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CONT)*2
	N_STMT_DEBUG_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DEBUG)*2 - 1
	N_STMT_DEBUG_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DEBUG)*2
	N_STMT_DO_WHILE_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DO_WHILE)*2 - 1
	N_STMT_DO_WHILE_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DO_WHILE)*2
	N_STMT_EXPORT_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPORT)*2 - 1
	N_STMT_EXPORT_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPORT)*2
	N_STMT_EXPR_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPR)*2 - 1
	N_STMT_EXPR_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPR)*2
	N_STMT_FN_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FN)*2 - 1
	N_STMT_FN_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FN)*2
	N_STMT_FOR_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR)*2 - 1
	N_STMT_FOR_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR)*2
	N_STMT_FOR_IN_OF_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR_IN_OF)*2 - 1
	N_STMT_FOR_IN_OF_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR_IN_OF)*2
	N_STMT_IF_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IF)*2 - 1
	N_STMT_IF_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IF)*2
	N_STMT_IMPORT_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IMPORT)*2 - 1
	N_STMT_IMPORT_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IMPORT)*2
	N_STMT_LABEL_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_LABEL)*2 - 1
	N_STMT_LABEL_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_LABEL)*2
	N_STMT_RET_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_RET)*2 - 1
	N_STMT_RET_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_RET)*2
	N_STMT_SWITCH_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_SWITCH)*2 - 1
	N_STMT_SWITCH_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_SWITCH)*2
	N_STMT_THROW_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_THROW)*2 - 1
	N_STMT_THROW_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_THROW)*2
	N_STMT_TRY_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_TRY)*2 - 1
	N_STMT_TRY_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_TRY)*2
	N_STMT_VAR_DEC_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_VAR_DEC)*2 - 1
	N_STMT_VAR_DEC_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_VAR_DEC)*2
	N_STMT_WHILE_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WHILE)*2 - 1
	N_STMT_WHILE_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WHILE)*2
	N_STMT_WITH_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WITH)*2 - 1
	N_STMT_WITH_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WITH)*2
	N_SUPER_BEFORE                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SUPER)*2 - 1
	N_SUPER_AFTER                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SUPER)*2
	N_SWITCH_CASE_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SWITCH_CASE)*2 - 1
	N_SWITCH_CASE_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SWITCH_CASE)*2
	N_TS_ANY_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ANY)*2 - 1
	N_TS_ANY_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ANY)*2
	N_TS_ARR_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ARR)*2 - 1
	N_TS_ARR_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ARR)*2
	N_TS_BIGINT_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BIGINT)*2 - 1
	N_TS_BIGINT_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BIGINT)*2
	N_TS_BOOL_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BOOL)*2 - 1
	N_TS_BOOL_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BOOL)*2
	N_TS_CALL_SIG_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_CALL_SIG)*2 - 1
	N_TS_CALL_SIG_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_CALL_SIG)*2
	N_TS_COND_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_COND)*2 - 1
	N_TS_COND_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_COND)*2
	N_TS_DEC_CLASS_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_CLASS)*2 - 1
	N_TS_DEC_CLASS_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_CLASS)*2
	N_TS_DEC_ENUM_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_ENUM)*2 - 1
	N_TS_DEC_ENUM_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_ENUM)*2
	N_TS_DEC_FN_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_FN)*2 - 1
	N_TS_DEC_FN_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_FN)*2
	N_TS_DEC_GLOBAL_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_GLOBAL)*2 - 1
	N_TS_DEC_GLOBAL_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_GLOBAL)*2
	N_TS_DEC_INTERFACE_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_INTERFACE)*2 - 1
	N_TS_DEC_INTERFACE_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_INTERFACE)*2
	N_TS_DEC_MODULE_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_MODULE)*2 - 1
	N_TS_DEC_MODULE_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_MODULE)*2
	N_TS_DEC_NS_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_NS)*2 - 1
	N_TS_DEC_NS_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_NS)*2
	N_TS_DEC_TYP_DEC_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_TYP_DEC)*2 - 1
	N_TS_DEC_TYP_DEC_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_TYP_DEC)*2
	N_TS_DEC_VAR_DEC_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_VAR_DEC)*2 - 1
	N_TS_DEC_VAR_DEC_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_VAR_DEC)*2
	N_TS_ENUM_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM)*2 - 1
	N_TS_ENUM_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM)*2
	N_TS_ENUM_MEMBER_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM_MEMBER)*2 - 1
	N_TS_ENUM_MEMBER_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM_MEMBER)*2
	N_TS_EXPORT_ASSIGN_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_EXPORT_ASSIGN)*2 - 1
	N_TS_EXPORT_ASSIGN_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_EXPORT_ASSIGN)*2
	N_TS_FN_TYP_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_FN_TYP)*2 - 1
	N_TS_FN_TYP_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_FN_TYP)*2
	N_TS_IDX_ACCESS_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_ACCESS)*2 - 1
	N_TS_IDX_ACCESS_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_ACCESS)*2
	N_TS_IDX_SIG_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_SIG)*2 - 1
	N_TS_IDX_SIG_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_SIG)*2
	N_TS_IMPORT_ALIAS_BEFORE       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_ALIAS)*2 - 1
	N_TS_IMPORT_ALIAS_AFTER        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_ALIAS)*2
	N_TS_IMPORT_REQUIRE_BEFORE     = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_REQUIRE)*2 - 1
	N_TS_IMPORT_REQUIRE_AFTER      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_REQUIRE)*2
	N_TS_IMPORT_TYP_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_TYP)*2 - 1
	N_TS_IMPORT_TYP_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_TYP)*2
	N_TS_INTERFACE_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE)*2 - 1
	N_TS_INTERFACE_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE)*2
	N_TS_INTERFACE_BODY_BEFORE     = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE_BODY)*2 - 1
	N_TS_INTERFACE_BODY_AFTER      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE_BODY)*2
	N_TS_INTERSECT_TYP_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERSECT_TYP)*2 - 1
	N_TS_INTERSECT_TYP_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERSECT_TYP)*2
	N_TS_INTRINSIC_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTRINSIC)*2 - 1
	N_TS_INTRINSIC_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTRINSIC)*2
	N_TS_LIT_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT)*2 - 1
	N_TS_LIT_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT)*2
	N_TS_LIT_OBJ_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT_OBJ)*2 - 1
	N_TS_LIT_OBJ_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT_OBJ)*2
	N_TS_MAPPED_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_MAPPED)*2 - 1
	N_TS_MAPPED_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_MAPPED)*2
	N_TS_NAMESPACE_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NAMESPACE)*2 - 1
	N_TS_NAMESPACE_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NAMESPACE)*2
	N_TS_NEVER_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEVER)*2 - 1
	N_TS_NEVER_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEVER)*2
	N_TS_NEW_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW)*2 - 1
	N_TS_NEW_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW)*2
	N_TS_NEW_SIG_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW_SIG)*2 - 1
	N_TS_NEW_SIG_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW_SIG)*2
	N_TS_NO_NULL_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NO_NULL)*2 - 1
	N_TS_NO_NULL_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NO_NULL)*2
	N_TS_NS_NAME_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NS_NAME)*2 - 1
	N_TS_NS_NAME_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NS_NAME)*2
	N_TS_NULL_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NULL)*2 - 1
	N_TS_NULL_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NULL)*2
	N_TS_NUM_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NUM)*2 - 1
	N_TS_NUM_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NUM)*2
	N_TS_OBJ_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OBJ)*2 - 1
	N_TS_OBJ_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OBJ)*2
	N_TS_OPT_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OPT)*2 - 1
	N_TS_OPT_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OPT)*2
	N_TS_PARAM_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM)*2 - 1
	N_TS_PARAM_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM)*2
	N_TS_PARAM_DEC_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_DEC)*2 - 1
	N_TS_PARAM_DEC_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_DEC)*2
	N_TS_PARAM_INST_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_INST)*2 - 1
	N_TS_PARAM_INST_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_INST)*2
	N_TS_PAREN_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PAREN)*2 - 1
	N_TS_PAREN_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PAREN)*2
	N_TS_PROP_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PROP)*2 - 1
	N_TS_PROP_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PROP)*2
	N_TS_REF_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REF)*2 - 1
	N_TS_REF_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REF)*2
	N_TS_REST_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REST)*2 - 1
	N_TS_REST_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REST)*2
	N_TS_ROUGH_PARAM_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ROUGH_PARAM)*2 - 1
	N_TS_ROUGH_PARAM_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ROUGH_PARAM)*2
	N_TS_STR_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_STR)*2 - 1
	N_TS_STR_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_STR)*2
	N_TS_SYM_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_SYM)*2 - 1
	N_TS_SYM_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_SYM)*2
	N_TS_THIS_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_THIS)*2 - 1
	N_TS_THIS_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_THIS)*2
	N_TS_TUPLE_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE)*2 - 1
	N_TS_TUPLE_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE)*2
	N_TS_TUPLE_NAMED_MEMBER_BEFORE = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE_NAMED_MEMBER)*2 - 1
	N_TS_TUPLE_NAMED_MEMBER_AFTER  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE_NAMED_MEMBER)*2
	N_TS_TYP_ANNOT_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ANNOT)*2 - 1
	N_TS_TYP_ANNOT_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ANNOT)*2
	N_TS_TYP_ASSERT_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ASSERT)*2 - 1
	N_TS_TYP_ASSERT_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ASSERT)*2
	N_TS_TYP_DEC_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_DEC)*2 - 1
	N_TS_TYP_DEC_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_DEC)*2
	N_TS_TYP_INFER_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_INFER)*2 - 1
	N_TS_TYP_INFER_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_INFER)*2
	N_TS_TYP_OP_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_OP)*2 - 1
	N_TS_TYP_OP_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_OP)*2
	N_TS_TYP_PREDICATE_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_PREDICATE)*2 - 1
	N_TS_TYP_PREDICATE_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_PREDICATE)*2
	N_TS_TYP_QUERY_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_QUERY)*2 - 1
	N_TS_TYP_QUERY_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_QUERY)*2
	N_TS_UNDEF_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNDEF)*2 - 1
	N_TS_UNDEF_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNDEF)*2
	N_TS_UNION_TYP_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNION_TYP)*2 - 1
	N_TS_UNION_TYP_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNION_TYP)*2
	N_TS_UNKNOWN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNKNOWN)*2 - 1
	N_TS_UNKNOWN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNKNOWN)*2
	N_TS_VOID_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_VOID)*2 - 1
	N_TS_VOID_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_VOID)*2
	N_VAR_DEC_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_VAR_DEC)*2 - 1
	N_VAR_DEC_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_VAR_DEC)*2

	N_BEFORE_AFTER_DEF_END = N_BEFORE_AFTER_DEF_BEGIN + parser.N_NODE_DEF_END*2
)

Variables ¶

View Source

var AtomNodeTypes = map[parser.NodeType]bool{
	N_EXPR_THIS:      true,
	N_JSX_EMPTY:      true,
	N_JSX_ID:         true,
	N_JSX_NS:         true,
	N_JSX_TXT:        true,
	N_LIT_BOOL:       true,
	N_LIT_NULL:       true,
	N_LIT_NUM:        true,
	N_LIT_REGEXP:     true,
	N_LIT_STR:        true,
	N_NAME:           true,
	N_STMT_DEBUG:     true,
	N_SUPER:          true,
	N_TS_ANY:         true,
	N_TS_BIGINT:      true,
	N_TS_BOOL:        true,
	N_TS_INTRINSIC:   true,
	N_TS_NEVER:       true,
	N_TS_NULL:        true,
	N_TS_NUM:         true,
	N_TS_OBJ:         true,
	N_TS_ROUGH_PARAM: true,
	N_TS_STR:         true,
	N_TS_SYM:         true,
	N_TS_THIS:        true,
	N_TS_UNDEF:       true,
	N_TS_UNKNOWN:     true,
	N_TS_VOID:        true,
}

View Source

var NodeAfterEvents = map[parser.NodeType]bool{}/* 143 elements not displayed */

View Source

var NodeBeforeEvents = map[parser.NodeType]bool{}/* 143 elements not displayed */

View Source

var NodeTypes = map[parser.NodeType]bool{}/* 143 elements not displayed */

View Source

var StmtNodeTypes = map[parser.NodeType]bool{
	N_STMT_BLOCK:     true,
	N_STMT_BRK:       true,
	N_STMT_CONT:      true,
	N_STMT_DEBUG:     true,
	N_STMT_DO_WHILE:  true,
	N_STMT_EXPORT:    true,
	N_STMT_EXPR:      true,
	N_STMT_FOR:       true,
	N_STMT_FOR_IN_OF: true,
	N_STMT_IF:        true,
	N_STMT_IMPORT:    true,
	N_STMT_LABEL:     true,
	N_STMT_RET:       true,
	N_STMT_SWITCH:    true,
	N_STMT_THROW:     true,
	N_STMT_TRY:       true,
	N_STMT_VAR_DEC:   true,
	N_STMT_WHILE:     true,
	N_STMT_WITH:      true,
}

Functions ¶

func AddAfterListener ¶

func AddAfterListener(ls *Listeners, impl *Listener)

func AddAtomListener ¶

func AddAtomListener(ls *Listeners, impl *Listener)

func AddBeforeListener ¶

func AddBeforeListener(ls *Listeners, impl *Listener)

func AddListener ¶

func AddListener(ls *Listeners, t parser.NodeType, impl *Listener) error

func AddNodeAfterListener ¶

func AddNodeAfterListener(ls *Listeners, t parser.NodeType, impl *Listener)

func AddNodeBeforeListener ¶

func AddNodeBeforeListener(ls *Listeners, t parser.NodeType, impl *Listener)

func CallListener ¶

func CallListener(t parser.NodeType, n parser.Node, key string, ctx *VisitorCtx)

func CallVisitor ¶

func CallVisitor(t parser.NodeType, n parser.Node, key string, ctx *VisitorCtx)

func NodeAfterEvent ¶

func NodeAfterEvent(t parser.NodeType) parser.NodeType

func NodeBeforeEvent ¶

func NodeBeforeEvent(t parser.NodeType) parser.NodeType

func RemoveListener ¶

func RemoveListener(ls *Listeners, t parser.NodeType, impl *Listener)

func SetVisitor ¶

func SetVisitor(vs *Visitors, t parser.NodeType, impl Visitor)

replace the default visitor with the specified one

func VisitArrLit ¶

func VisitArrLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrLitAfter ¶

func VisitArrLitAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrLitBefore ¶

func VisitArrLitBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrPat ¶

func VisitArrPat(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrPatAfter ¶

func VisitArrPatAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrPatBefore ¶

func VisitArrPatBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrowFn ¶

func VisitArrowFn(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrowFnAfter ¶

func VisitArrowFnAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitArrowFnBefore ¶

func VisitArrowFnBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitAssignExpr ¶

func VisitAssignExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitAssignExprAfter ¶

func VisitAssignExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitAssignExprBefore ¶

func VisitAssignExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitAssignPat ¶

func VisitAssignPat(node parser.Node, key string, ctx *VisitorCtx)

func VisitAssignPatAfter ¶

func VisitAssignPatAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitAssignPatBefore ¶

func VisitAssignPatBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitBinExpr ¶

func VisitBinExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitBinExprAfter ¶

func VisitBinExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitBinExprBefore ¶

func VisitBinExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitBlockStmt ¶

func VisitBlockStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitBlockStmtAfter ¶

func VisitBlockStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitBlockStmtBefore ¶

func VisitBlockStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitBoolLit ¶

func VisitBoolLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitBrkStmt ¶

func VisitBrkStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitBrkStmtAfter ¶

func VisitBrkStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitBrkStmtBefore ¶

func VisitBrkStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitCallExpr ¶

func VisitCallExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitCallExprAfter ¶

func VisitCallExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitCallExprBefore ¶

func VisitCallExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitCatch ¶

func VisitCatch(node parser.Node, key string, ctx *VisitorCtx)

func VisitCatchAfter ¶

func VisitCatchAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitCatchBefore ¶

func VisitCatchBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitChainExpr ¶

func VisitChainExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitChainExprAfter ¶

func VisitChainExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitChainExprBefore ¶

func VisitChainExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitClassBody ¶

func VisitClassBody(node parser.Node, key string, ctx *VisitorCtx)

func VisitClassBodyAfter ¶

func VisitClassBodyAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitClassBodyBefore ¶

func VisitClassBodyBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitClassDec ¶

func VisitClassDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitClassDecAfter ¶

func VisitClassDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitClassDecBefore ¶

func VisitClassDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitCondExpr ¶

func VisitCondExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitCondExprAfter ¶

func VisitCondExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitCondExprBefore ¶

func VisitCondExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitContStmt ¶

func VisitContStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitContStmtAfter ¶

func VisitContStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitContStmtBefore ¶

func VisitContStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitDebugStmt ¶

func VisitDebugStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitDecorator ¶

func VisitDecorator(node parser.Node, key string, ctx *VisitorCtx)

func VisitDecoratorAfter ¶

func VisitDecoratorAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitDecoratorBefore ¶

func VisitDecoratorBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitDoWhileStmt ¶

func VisitDoWhileStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitDoWhileStmtAfter ¶

func VisitDoWhileStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitDoWhileStmtBefore ¶

func VisitDoWhileStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitExportDec ¶

func VisitExportDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitExportDecAfter ¶

func VisitExportDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitExportDecBefore ¶

func VisitExportDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitExportSpec ¶

func VisitExportSpec(node parser.Node, key string, ctx *VisitorCtx)

func VisitExportSpecAfter ¶

func VisitExportSpecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitExportSpecBefore ¶

func VisitExportSpecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitExprStmt ¶

func VisitExprStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitExprStmtAfter ¶

func VisitExprStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitExprStmtBefore ¶

func VisitExprStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitField ¶

func VisitField(node parser.Node, key string, ctx *VisitorCtx)

func VisitFieldAfter ¶

func VisitFieldAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitFieldBefore ¶

func VisitFieldBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitFnDec ¶

func VisitFnDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitFnDecAfter ¶

func VisitFnDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitFnDecBefore ¶

func VisitFnDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitForInOfStmt ¶

func VisitForInOfStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitForInOfStmtAfter ¶

func VisitForInOfStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitForInOfStmtBefore ¶

func VisitForInOfStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitForStmt ¶

func VisitForStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitForStmtAfter ¶

func VisitForStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitForStmtBefore ¶

func VisitForStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitIdent ¶

func VisitIdent(node parser.Node, key string, ctx *VisitorCtx)

func VisitIfStmt ¶

func VisitIfStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitIfStmtAfter ¶

func VisitIfStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitIfStmtBefore ¶

func VisitIfStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportCall ¶

func VisitImportCall(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportCallAfter ¶

func VisitImportCallAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportCallBefore ¶

func VisitImportCallBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportDec ¶

func VisitImportDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportDecAfter ¶

func VisitImportDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportDecBefore ¶

func VisitImportDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportSpec ¶

func VisitImportSpec(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportSpecAfter ¶

func VisitImportSpecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitImportSpecBefore ¶

func VisitImportSpecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxAttr ¶

func VisitJsxAttr(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxAttrAfter ¶

func VisitJsxAttrAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxAttrBefore ¶

func VisitJsxAttrBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxClose ¶

func VisitJsxClose(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxCloseAfter ¶

func VisitJsxCloseAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxCloseBefore ¶

func VisitJsxCloseBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxElem ¶

func VisitJsxElem(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxElemAfter ¶

func VisitJsxElemAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxElemBefore ¶

func VisitJsxElemBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxEmpty ¶

func VisitJsxEmpty(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxExprSpan ¶

func VisitJsxExprSpan(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxExprSpanAfter ¶

func VisitJsxExprSpanAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxExprSpanBefore ¶

func VisitJsxExprSpanBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxIdent ¶

func VisitJsxIdent(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxMember ¶

func VisitJsxMember(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxMemberAfter ¶

func VisitJsxMemberAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxMemberBefore ¶

func VisitJsxMemberBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxNsName ¶

func VisitJsxNsName(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxOpen ¶

func VisitJsxOpen(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxOpenAfter ¶

func VisitJsxOpenAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxOpenBefore ¶

func VisitJsxOpenBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxSpreadAttr ¶

func VisitJsxSpreadAttr(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxSpreadAttrAfter ¶

func VisitJsxSpreadAttrAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxSpreadAttrBefore ¶

func VisitJsxSpreadAttrBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxSpreadChild ¶

func VisitJsxSpreadChild(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxSpreadChildAfter ¶

func VisitJsxSpreadChildAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxSpreadChildBefore ¶

func VisitJsxSpreadChildBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitJsxText ¶

func VisitJsxText(node parser.Node, key string, ctx *VisitorCtx)

func VisitLabelStmt ¶

func VisitLabelStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitLabelStmtAfter ¶

func VisitLabelStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitLabelStmtBefore ¶

func VisitLabelStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitMemberExpr ¶

func VisitMemberExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitMemberExprAfter ¶

func VisitMemberExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitMemberExprBefore ¶

func VisitMemberExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitMetaProp ¶

func VisitMetaProp(node parser.Node, key string, ctx *VisitorCtx)

func VisitMetaPropAfter ¶

func VisitMetaPropAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitMetaPropBefore ¶

func VisitMetaPropBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitMethod ¶

func VisitMethod(node parser.Node, key string, ctx *VisitorCtx)

func VisitMethodAfter ¶

func VisitMethodAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitMethodBefore ¶

func VisitMethodBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitNewExpr ¶

func VisitNewExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitNewExprAfter ¶

func VisitNewExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitNewExprBefore ¶

func VisitNewExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitNode ¶

func VisitNode(n parser.Node, key string, ctx *VisitorCtx)

func VisitNodes ¶

func VisitNodes(n parser.Node, ns []parser.Node, key string, ctx *VisitorCtx)

func VisitNodesWithCb ¶

func VisitNodesWithCb(n parser.Node, ns []parser.Node, key string, ctx *VisitorCtx, cb VisitNodesCb)

func VisitNullLit ¶

func VisitNullLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitNumLit ¶

func VisitNumLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitObjLit ¶

func VisitObjLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitObjLitAfter ¶

func VisitObjLitAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitObjLitBefore ¶

func VisitObjLitBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitObjPat ¶

func VisitObjPat(node parser.Node, key string, ctx *VisitorCtx)

func VisitObjPatAfter ¶

func VisitObjPatAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitObjPatBefore ¶

func VisitObjPatBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitParenExpr ¶

func VisitParenExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitParenExprAfter ¶

func VisitParenExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitParenExprBefore ¶

func VisitParenExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitProg ¶

func VisitProg(node parser.Node, key string, ctx *VisitorCtx)

func VisitProgAfter ¶

func VisitProgAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitProgBefore ¶

func VisitProgBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitProp ¶

func VisitProp(node parser.Node, key string, ctx *VisitorCtx)

func VisitPropAfter ¶

func VisitPropAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitPropBefore ¶

func VisitPropBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitRegLit ¶

func VisitRegLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitRestPat ¶

func VisitRestPat(node parser.Node, key string, ctx *VisitorCtx)

func VisitRestPatAfter ¶

func VisitRestPatAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitRestPatBefore ¶

func VisitRestPatBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitRetStmt ¶

func VisitRetStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitRetStmtAfter ¶

func VisitRetStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitRetStmtBefore ¶

func VisitRetStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitSeqExpr ¶

func VisitSeqExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitSeqExprAfter ¶

func VisitSeqExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitSeqExprBefore ¶

func VisitSeqExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitSpread ¶

func VisitSpread(node parser.Node, key string, ctx *VisitorCtx)

func VisitSpreadAfter ¶

func VisitSpreadAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitSpreadBefore ¶

func VisitSpreadBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitStaticBlock ¶

func VisitStaticBlock(node parser.Node, key string, ctx *VisitorCtx)

func VisitStaticBlockAfter ¶

func VisitStaticBlockAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitStaticBlockBefore ¶

func VisitStaticBlockBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitStrLit ¶

func VisitStrLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitSuper ¶

func VisitSuper(node parser.Node, key string, ctx *VisitorCtx)

func VisitSwitchCase ¶

func VisitSwitchCase(node parser.Node, key string, ctx *VisitorCtx)

func VisitSwitchCaseAfter ¶

func VisitSwitchCaseAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitSwitchCaseBefore ¶

func VisitSwitchCaseBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitSwitchStmt ¶

func VisitSwitchStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitSwitchStmtAfter ¶

func VisitSwitchStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitSwitchStmtBefore ¶

func VisitSwitchStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitThisExpr ¶

func VisitThisExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitThrowStmt ¶

func VisitThrowStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitThrowStmtAfter ¶

func VisitThrowStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitThrowStmtBefore ¶

func VisitThrowStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTplExpr ¶

func VisitTplExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitTplExprAfter ¶

func VisitTplExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTplExprBefore ¶

func VisitTplExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTryStmt ¶

func VisitTryStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitTryStmtAfter ¶

func VisitTryStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTryStmtBefore ¶

func VisitTryStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsArr ¶

func VisitTsArr(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsArrAfter ¶

func VisitTsArrAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsArrBefore ¶

func VisitTsArrBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsCallSig ¶

func VisitTsCallSig(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsCallSigAfter ¶

func VisitTsCallSigAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsCallSigBefore ¶

func VisitTsCallSigBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsCondType ¶

func VisitTsCondType(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsCondTypeAfter ¶

func VisitTsCondTypeAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsCondTypeBefore ¶

func VisitTsCondTypeBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsDec ¶

func VisitTsDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsDecAfter ¶

func VisitTsDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsDecBefore ¶

func VisitTsDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsEnum ¶

func VisitTsEnum(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsEnumAfter ¶

func VisitTsEnumAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsEnumBefore ¶

func VisitTsEnumBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsEnumMember ¶

func VisitTsEnumMember(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsEnumMemberAfter ¶

func VisitTsEnumMemberAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsEnumMemberBefore ¶

func VisitTsEnumMemberBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsExportAssign ¶

func VisitTsExportAssign(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsExportAssignAfter ¶

func VisitTsExportAssignAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsExportAssignBefore ¶

func VisitTsExportAssignBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsFnTyp ¶

func VisitTsFnTyp(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsFnTypAfter ¶

func VisitTsFnTypAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsFnTypBefore ¶

func VisitTsFnTypBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIdxAccess ¶

func VisitTsIdxAccess(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIdxAccessAfter ¶

func VisitTsIdxAccessAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIdxAccessBefore ¶

func VisitTsIdxAccessBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIdxSig ¶

func VisitTsIdxSig(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIdxSigAfter ¶

func VisitTsIdxSigAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIdxSigBefore ¶

func VisitTsIdxSigBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportAlias ¶

func VisitTsImportAlias(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportAliasAfter ¶

func VisitTsImportAliasAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportAliasBefore ¶

func VisitTsImportAliasBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportRequire ¶

func VisitTsImportRequire(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportRequireAfter ¶

func VisitTsImportRequireAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportRequireBefore ¶

func VisitTsImportRequireBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportType ¶

func VisitTsImportType(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportTypeAfter ¶

func VisitTsImportTypeAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsImportTypeBefore ¶

func VisitTsImportTypeBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsInterface ¶

func VisitTsInterface(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsInterfaceAfter ¶

func VisitTsInterfaceAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsInterfaceBefore ¶

func VisitTsInterfaceBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsInterfaceBody ¶

func VisitTsInterfaceBody(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsInterfaceBodyAfter ¶

func VisitTsInterfaceBodyAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsInterfaceBodyBefore ¶

func VisitTsInterfaceBodyBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIntersectTyp ¶

func VisitTsIntersectTyp(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIntersectTypAfter ¶

func VisitTsIntersectTypAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsIntersectTypBefore ¶

func VisitTsIntersectTypBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsLit ¶

func VisitTsLit(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsLitAfter ¶

func VisitTsLitAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsLitBefore ¶

func VisitTsLitBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsMapped ¶

func VisitTsMapped(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsMappedAfter ¶

func VisitTsMappedAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsMappedBefore ¶

func VisitTsMappedBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNS ¶

func VisitTsNS(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNSAfter ¶

func VisitTsNSAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNSBefore ¶

func VisitTsNSBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNewSig ¶

func VisitTsNewSig(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNewSigAfter ¶

func VisitTsNewSigAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNewSigBefore ¶

func VisitTsNewSigBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNoNull ¶

func VisitTsNoNull(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNoNullAfter ¶

func VisitTsNoNullAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNoNullBefore ¶

func VisitTsNoNullBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNsName ¶

func VisitTsNsName(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNsNameAfter ¶

func VisitTsNsNameAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsNsNameBefore ¶

func VisitTsNsNameBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsObj ¶

func VisitTsObj(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsObjAfter ¶

func VisitTsObjAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsObjBefore ¶

func VisitTsObjBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsOpt ¶

func VisitTsOpt(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsOptAfter ¶

func VisitTsOptAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsOptBefore ¶

func VisitTsOptBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParam ¶

func VisitTsParam(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamAfter ¶

func VisitTsParamAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamBefore ¶

func VisitTsParamBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamsDec ¶

func VisitTsParamsDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamsDecAfter ¶

func VisitTsParamsDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamsDecBefore ¶

func VisitTsParamsDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamsInst ¶

func VisitTsParamsInst(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamsInstAfter ¶

func VisitTsParamsInstAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParamsInstBefore ¶

func VisitTsParamsInstBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParen ¶

func VisitTsParen(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParenAfter ¶

func VisitTsParenAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsParenBefore ¶

func VisitTsParenBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsPredef ¶

func VisitTsPredef(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsProp ¶

func VisitTsProp(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsPropAfter ¶

func VisitTsPropAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsPropBefore ¶

func VisitTsPropBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRef ¶

func VisitTsRef(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRefAfter ¶

func VisitTsRefAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRefBefore ¶

func VisitTsRefBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRest ¶

func VisitTsRest(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRestAfter ¶

func VisitTsRestAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRestBefore ¶

func VisitTsRestBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsRoughParam ¶

func VisitTsRoughParam(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsThis ¶

func VisitTsThis(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTuple ¶

func VisitTsTuple(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTupleAfter ¶

func VisitTsTupleAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTupleBefore ¶

func VisitTsTupleBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTupleNamedMember ¶

func VisitTsTupleNamedMember(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTupleNamedMemberAfter ¶

func VisitTsTupleNamedMemberAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTupleNamedMemberBefore ¶

func VisitTsTupleNamedMemberBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypAnnot ¶

func VisitTsTypAnnot(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypAnnotAfter ¶

func VisitTsTypAnnotAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypAnnotBefore ¶

func VisitTsTypAnnotBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypAssert ¶

func VisitTsTypAssert(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypAssertAfter ¶

func VisitTsTypAssertAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypAssertBefore ¶

func VisitTsTypAssertBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypDec ¶

func VisitTsTypDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypDecAfter ¶

func VisitTsTypDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypDecBefore ¶

func VisitTsTypDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypInfer ¶

func VisitTsTypInfer(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypInferAfter ¶

func VisitTsTypInferAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypInferBefore ¶

func VisitTsTypInferBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypOp ¶

func VisitTsTypOp(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypOpAfter ¶

func VisitTsTypOpAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypOpBefore ¶

func VisitTsTypOpBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypPredicate ¶

func VisitTsTypPredicate(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypPredicateAfter ¶

func VisitTsTypPredicateAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypPredicateBefore ¶

func VisitTsTypPredicateBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypQuery ¶

func VisitTsTypQuery(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypQueryAfter ¶

func VisitTsTypQueryAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsTypQueryBefore ¶

func VisitTsTypQueryBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsUnionTyp ¶

func VisitTsUnionTyp(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsUnionTypAfter ¶

func VisitTsUnionTypAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitTsUnionTypBefore ¶

func VisitTsUnionTypBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitUnaryExpr ¶

func VisitUnaryExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitUnaryExprAfter ¶

func VisitUnaryExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitUnaryExprBefore ¶

func VisitUnaryExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitUpdateExpr ¶

func VisitUpdateExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitUpdateExprAfter ¶

func VisitUpdateExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitUpdateExprBefore ¶

func VisitUpdateExprBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitVarDec ¶

func VisitVarDec(node parser.Node, key string, ctx *VisitorCtx)

func VisitVarDecAfter ¶

func VisitVarDecAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitVarDecBefore ¶

func VisitVarDecBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitVarDecStmt ¶

func VisitVarDecStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitVarDecStmtAfter ¶

func VisitVarDecStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitVarDecStmtBefore ¶

func VisitVarDecStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitWhileStmt ¶

func VisitWhileStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitWhileStmtAfter ¶

func VisitWhileStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitWhileStmtBefore ¶

func VisitWhileStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitWithStmt ¶

func VisitWithStmt(node parser.Node, key string, ctx *VisitorCtx)

func VisitWithStmtAfter ¶

func VisitWithStmtAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitWithStmtBefore ¶

func VisitWithStmtBefore(node parser.Node, key string, ctx *VisitorCtx)

func VisitYieldExpr ¶

func VisitYieldExpr(node parser.Node, key string, ctx *VisitorCtx)

func VisitYieldExprAfter ¶

func VisitYieldExprAfter(node parser.Node, key string, ctx *VisitorCtx)

func VisitYieldExprBefore ¶

func VisitYieldExprBefore(node parser.Node, key string, ctx *VisitorCtx)

Types ¶

type CondNewScope ¶

type CondNewScope interface {
	NewScope() bool
}

type ListenFn ¶

type ListenFn = func(node parser.Node, key string, ctx *VisitorCtx)

type Listener ¶

type Listener struct {
	Id     string
	Handle ListenFn
}

type Listeners ¶

type Listeners = [N_BEFORE_AFTER_DEF_END]*util.OrderedMap[string, *Listener]

var DefaultListeners Listeners = [N_BEFORE_AFTER_DEF_END]*util.OrderedMap[string, *Listener]{}

type VisitNodesCb ¶

type VisitNodesCb = func(ctx *VisitorCtx)

type Visitor ¶

type Visitor = func(node parser.Node, key string, ctx *VisitorCtx)

type VisitorCtx ¶

type VisitorCtx struct {
	WalkCtx *WalkCtx    // ctx of the entire walk
	Parent  *VisitorCtx // ctx of the parent node

	Path []string    // path of current node, if `WalkCtx.Path` is turned on
	Node parser.Node // current node
}

func (*VisitorCtx) ParentIsJmp ¶

func (vc *VisitorCtx) ParentIsJmp(key string) bool

func (*VisitorCtx) ParentNode ¶

func (vc *VisitorCtx) ParentNode() parser.Node

func (*VisitorCtx) ParentNodeType ¶

func (vc *VisitorCtx) ParentNodeType() parser.NodeType

func (*VisitorCtx) Scope ¶

func (c *VisitorCtx) Scope() *parser.Scope

func (*VisitorCtx) ScopeId ¶

func (c *VisitorCtx) ScopeId() int

type Visitors ¶

type Visitors = [N_BEFORE_AFTER_DEF_END]Visitor

var DefaultVisitors Visitors = [N_BEFORE_AFTER_DEF_END]Visitor{}

type WalkCtx ¶

type WalkCtx struct {
	Visitors    Visitors
	Listeners   Listeners
	RaiseNoImpl bool

	Path  bool        // whether to record the path of node
	Extra interface{} // attach extra infos for biz logic

	Root   parser.Node    // the root node to start walking
	Symtab *parser.SymTab // the symtab associated with the Root
	// contains filtered or unexported fields
}

func NewWalkCtx ¶

func NewWalkCtx(root parser.Node, symtab *parser.SymTab) *WalkCtx

func (*WalkCtx) PopScope ¶

func (c *WalkCtx) PopScope()

func (*WalkCtx) PopVisitorCtx ¶

func (c *WalkCtx) PopVisitorCtx()

func (*WalkCtx) PushScope ¶

func (c *WalkCtx) PushScope()

func (*WalkCtx) PushVisitorCtx ¶

func (c *WalkCtx) PushVisitorCtx(node parser.Node, path string)

func (*WalkCtx) Scope ¶

func (c *WalkCtx) Scope() *parser.Scope

func (*WalkCtx) ScopeId ¶

func (c *WalkCtx) ScopeId() int

func (*WalkCtx) Stop ¶

func (c *WalkCtx) Stop()

func (*WalkCtx) Stopped ¶

func (c *WalkCtx) Stopped() bool

func (*WalkCtx) VisitorCtx ¶

func (c *WalkCtx) VisitorCtx() *VisitorCtx

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL