acorn-walk.node.txt

                                  ┏━━━━━━━━━━━━━━━━┓
                                  ┃   ACORN-WALK   ┃
                                  ┗━━━━━━━━━━━━━━━━┛

ALTERNATIVES ==>                  #  - acorn-walk (preferred with acorn)
                                  #  - eslint-visitor-keys (preferred with espree)

VERSION ==>                       #See Acorn

AST FORMAT ==>                    #ESTree

NODE.type                         #Include abstract types: 'Expression', 'Statement', 'Pattern', 'Function'
                                  #Add: 'ForInit' (first part of "for in|of")
                                  #Do not include: 'ExportSpecifier', 'ClassBody', 'SwitchCase'

                                  ┌────────────────┐
                                  │   TRAVERSING   │
                                  └────────────────┘

WALK.simple(NODE, OBJ)            #Walk through AST tree and call OBJ.TYPE(CHILD_NODE) for each CHILD_NODE whose type is TYPE.
                                  #Start with leaves, end with root.

WALK.ancestors(NODE, OBJ)         #Same but instead call OBJ.TYPE(CHILD_NODE, ANCESTOR_NODE_ARR)
                                  #ANCESTOR_NODE_ARR starts with ancestor and ends with CHILD_NODE.

WALK.full[Ancestors](NODE, FUNC)  #Same as two previous except using FUNC(CHILD_NODE, ...) for any CHILD_NODE

WALK.recursive(NODE)              #Same except does not trigger any callbacks. Only useful when BASE_OBJ is overridden.

                                  ┌─────────────┐
                                  │   FINDING   │
                                  └─────────────┘

WALK.findNodeAt                   #Returns { node NODE2 } with first NODE2 where:
(NODE[, START_OFFSET[, END_OFFSET #  - NODE2.start === START_OFFSET
[,'TYP'|FUNC('TYP',NODE)->BOOL]]])#  - NODE2.end === END_OFFSET
[->OBJ]                           #  - 'TYPE'|FUNC()->true
                                  #OFFSET is file-wise (not line-wise).
                                  #Returns undefined if none found
WALK.findNodeAround(NODE, OFFSET,
['TYPE'|FUNC('TYPE', NODE)->BOOL])
->OBJ                             #Same with NODE2.start <= OFFSET <= NODE.end
WALK.findNodeAfter(NODE, OFFSET,
['TYPE'|FUNC('TYPE', NODE)->BOOL])
->OBJ                             #Same with NODE2.start >= OFFSET
WALK.findNodeBefore(NODE, OFFSET,
['TYPE'|FUNC('TYPE', NODE)->BOOL])
->OBJ                             #Same with OFFSET <= NODE.end

                                  ┌───────────────────┐
                                  │   CUSTOMIZATION   │
                                  └───────────────────┘

WALK.*(..., STATE_OBJ)            #Every function can pass a STATE_OBJ that is passed as last argument to callbacks

WALK.*(..., BASE_OBJ)             #Every function can pass a BASE_OBJ to customize the walker.
                                  #BASE_OBJ is { TYPE(NODE, STATE_OBJ, FUNC), ... }
                                  #  - must call FUNC(NODE, STATE_OBJ[, 'TYPE']) on children
                                  #     - 'TYPE' defaults to NODE.type
WALK.base                         #Default BASE_OBJ
make(OBJ)->OBJ                    #Same as { ...WALK.base, ...OBJ }