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
Redistributable license
Tagged version
Stable version
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